/**
 * Hosted DNS: put registered domains on ird nameservers, manage the hosted
 * zones' records, DNSSEC and nameserver set, and bring domains held at other
 * registrars onto ird DNS through claims. Mutations are subject to the
 * client's domain gate when configured.
 */
import type { Client } from './client.js';
import type { Body, Query } from './types.js';
/** POST /domains/registrations/{id}/dns — Put a domain on ird nameservers (202). */
export declare const enableHosting: (client: Client, id: string, body?: Body<"/domains/registrations/{id}/dns", "post">) => Promise<{
    nameservers: string[];
    nameservers_mode: "shared" | "labels";
    nameservers_ready: boolean;
    origin: string;
    registry_action: {
        [key: string]: unknown;
    } | null;
    registry_error?: string;
    zones: {
        created_at: string;
        default_ttl: number;
        nameservers: string[];
        node: string;
        origin: string;
    }[];
}>;
/** DELETE /domains/registrations/{id}/dns — Take a domain off ird DNS. */
export declare const disableHosting: (client: Client, id: string, body?: Body<"/domains/registrations/{id}/dns", "delete">) => Promise<{
    decommissioned: boolean;
    snapshot_id: string;
    zones_deleted: number;
}>;
/** GET /domains/registrations/{id}/dns/dnssec — DNSSEC state of the hosted zone. */
export declare const getDnssec: (client: Client, id: string) => Promise<{
    dnssec: {
        ds?: {
            alg: number;
            digest: string;
            digest_type: number;
            keytag: number;
        };
        not_before?: string;
        state: "pending-nodes" | "awaiting-ds" | "ds-published" | "removing-ds" | "unsigning-hold" | "disabled";
    };
}>;
/** POST /domains/registrations/{id}/dns/dnssec — Enable DNSSEC on the hosted zone (202). */
export declare const enableDnssec: (client: Client, id: string, body?: Body<"/domains/registrations/{id}/dns/dnssec", "post">) => Promise<{
    dnssec: {
        ds?: {
            alg: number;
            digest: string;
            digest_type: number;
            keytag: number;
        };
        not_before?: string;
        state: "pending-nodes" | "awaiting-ds" | "ds-published" | "removing-ds" | "unsigning-hold" | "disabled";
    };
}>;
/** DELETE /domains/registrations/{id}/dns/dnssec — Disable DNSSEC on the hosted zone (202). */
export declare const disableDnssec: (client: Client, id: string, body?: Body<"/domains/registrations/{id}/dns/dnssec", "delete">) => Promise<{
    dnssec: {
        ds?: {
            alg: number;
            digest: string;
            digest_type: number;
            keytag: number;
        };
        not_before?: string;
        state: "pending-nodes" | "awaiting-ds" | "ds-published" | "removing-ds" | "unsigning-hold" | "disabled";
    };
}>;
/**
 * GET /domains/registrations/{id}/dns/nameservers — The nameserver set the
 * hosted zone is published under: `mode` "shared" (ird's public nameservers)
 * or "labels" (private nameservers unique to the domain), with
 * `nameservers`, `nameservers_ready` and `available_modes`. Free.
 */
export declare const hostedNameservers: (client: Client, id: string) => Promise<{
    available_modes: ("shared" | "labels")[];
    mode: "shared" | "labels";
    nameservers: string[];
    nameservers_ready: boolean;
    origin: string;
}>;
/**
 * POST /domains/registrations/{id}/dns/nameservers — Move the hosted zone
 * between nameserver sets: `mode` "shared" or "labels" (labels are offered
 * for .ro domains only). Answers 200 when nothing had to change, 202 with a
 * `registry_action` when a registrar nameserver change was enqueued — poll
 * `hostedNameservers` for `nameservers_ready`. Free.
 */
export declare const setHostedNameservers: (client: Client, id: string, body: Body<"/domains/registrations/{id}/dns/nameservers", "post">) => Promise<{
    available_modes: ("shared" | "labels")[];
    mode: "shared" | "labels";
    nameservers: string[];
    nameservers_ready: boolean;
    origin: string;
    registry_action: null;
} | {
    available_modes: ("shared" | "labels")[];
    mode: "shared" | "labels";
    nameservers: string[];
    nameservers_ready: boolean;
    origin: string;
    registry_action: {
        [key: string]: unknown;
    } | null;
    registry_error?: string;
}>;
/** GET /dns/domains — Your hosted DNS domains. */
export declare const listZones: (client: Client) => Promise<{
    domains: {
        default_ttl: number;
        delegated?: boolean;
        nodes: string[];
        origin: string;
    }[];
}>;
/** GET /dns/domains/{domain} — A hosted domain's zone. */
export declare const getZone: (client: Client, domain: string) => Promise<{
    default_ttl: number;
    nameservers: string[];
    nameservers_mode: "shared" | "labels";
    nodes: string[];
    origin: string;
    records: {
        class: string;
        connection_id?: string;
        data: {
            [key: string]: unknown;
        };
        deployment_id?: string;
        instance_id?: string;
        managed_by?: "tunnel" | "app" | "vps" | "platform";
        name: string;
        purpose?: string;
        ttl: number | null;
        tunnel_id?: string;
        type: string;
    }[];
}>;
/** PUT /dns/domains/{domain}/records — Set a DNS record or RRset. */
export declare const setRecord: (client: Client, domain: string, body: Body<"/dns/domains/{domain}/records", "put">) => Promise<{
    record: {
        class: string;
        data: {
            [key: string]: unknown;
        };
        name: string;
        ttl: number | null;
        type: string;
    };
    records: {
        class: string;
        data: {
            [key: string]: unknown;
        };
        name: string;
        ttl: number | null;
        type: string;
    }[];
}>;
/** DELETE /dns/domains/{domain}/records — Delete a DNS record (carries a JSON body). */
export declare const deleteRecord: (client: Client, domain: string, body: Body<"/dns/domains/{domain}/records", "delete">) => Promise<{
    deleted: boolean;
}>;
/**
 * GET /dns/claims — Domains you hold at another registrar and host (or are
 * about to host) on ird DNS: every live claim plus those ended in the last
 * 30 days, newest first. Optional `state` (pending / verified / active /
 * lapsed / revoked / expired) and `limit` (1..500, default 50).
 */
export declare const listClaims: (client: Client, query?: Query<"/dns/claims", "get">) => Promise<{
    claims: {
        activated_at: string | null;
        created_at: string;
        delegation: {
            checked_at: string | null;
            deadline_at: string | null;
            ds_present: boolean;
            lost_at: string | null;
            names: string[];
            ok: boolean;
            partial: boolean;
        };
        domain: string;
        domain_unicode: string;
        end_reason: ("released" | "superseded" | "registered" | "admin" | "not-verified" | "not-delegated" | "delegation-lost" | "grace-expired" | "registry-gone") | null;
        ended_at: string | null;
        expires_at: string | null;
        id: string;
        last_check: {
            ds_present?: boolean;
            error?: string;
            message?: string;
            missing?: string[];
            names?: string[];
            nameserver_count?: number;
            ok: boolean;
            reason?: ("parent-unreachable" | "not-delegated" | "partial" | "delegated-to-ird" | "elsewhere" | "expired" | "activation-refused") | null;
        } | null;
        nameservers: string[];
        registry: {
            checked_at: string | null;
            expires_at: string | null;
            status: {
                [key: string]: unknown;
            } | null;
        };
        seed?: {
            meta?: {
                [key: string]: unknown;
            } | null;
            nameservers: string[];
            record_count: number;
            records: {
                [key: string]: unknown;
            }[];
            snapshot_id: string;
            taken_at: string | null;
        } | null;
        seed_snapshot_id: string | null;
        sensitive: boolean;
        state: "pending" | "verified" | "active" | "lapsed" | "revoked" | "expired";
        verified_at: string | null;
    }[];
}>;
/**
 * POST /dns/claims — Claim a registrable domain registered elsewhere so ird
 * can be its DNS (201). The response's `claim` carries the `nameservers` to
 * set at your registrar; the claim activates once the parent zone lists
 * exactly those (checked every few minutes, or now via `verifyClaim`).
 * Gated on `domain`.
 */
export declare const createClaim: (client: Client, body: Body<"/dns/claims", "post">) => Promise<{
    claim: {
        activated_at: string | null;
        created_at: string;
        delegation: {
            checked_at: string | null;
            deadline_at: string | null;
            ds_present: boolean;
            lost_at: string | null;
            names: string[];
            ok: boolean;
            partial: boolean;
        };
        domain: string;
        domain_unicode: string;
        end_reason: ("released" | "superseded" | "registered" | "admin" | "not-verified" | "not-delegated" | "delegation-lost" | "grace-expired" | "registry-gone") | null;
        ended_at: string | null;
        expires_at: string | null;
        id: string;
        last_check: {
            ds_present?: boolean;
            error?: string;
            message?: string;
            missing?: string[];
            names?: string[];
            nameserver_count?: number;
            ok: boolean;
            reason?: ("parent-unreachable" | "not-delegated" | "partial" | "delegated-to-ird" | "elsewhere" | "expired" | "activation-refused") | null;
        } | null;
        nameservers: string[];
        registry: {
            checked_at: string | null;
            expires_at: string | null;
            status: {
                [key: string]: unknown;
            } | null;
        };
        seed?: {
            meta?: {
                [key: string]: unknown;
            } | null;
            nameservers: string[];
            record_count: number;
            records: {
                [key: string]: unknown;
            }[];
            snapshot_id: string;
            taken_at: string | null;
        } | null;
        seed_snapshot_id: string | null;
        sensitive: boolean;
        state: "pending" | "verified" | "active" | "lapsed" | "revoked" | "expired";
        verified_at: string | null;
    };
}>;
/**
 * GET /dns/claims/{id} — A claim: nameservers to set, its window while
 * pending, the latest delegation read and registry facts.
 */
export declare const getClaim: (client: Client, id: string) => Promise<{
    claim: {
        activated_at: string | null;
        created_at: string;
        delegation: {
            checked_at: string | null;
            deadline_at: string | null;
            ds_present: boolean;
            lost_at: string | null;
            names: string[];
            ok: boolean;
            partial: boolean;
        };
        domain: string;
        domain_unicode: string;
        end_reason: ("released" | "superseded" | "registered" | "admin" | "not-verified" | "not-delegated" | "delegation-lost" | "grace-expired" | "registry-gone") | null;
        ended_at: string | null;
        expires_at: string | null;
        id: string;
        last_check: {
            ds_present?: boolean;
            error?: string;
            message?: string;
            missing?: string[];
            names?: string[];
            nameserver_count?: number;
            ok: boolean;
            reason?: ("parent-unreachable" | "not-delegated" | "partial" | "delegated-to-ird" | "elsewhere" | "expired" | "activation-refused") | null;
        } | null;
        nameservers: string[];
        registry: {
            checked_at: string | null;
            expires_at: string | null;
            status: {
                [key: string]: unknown;
            } | null;
        };
        seed?: {
            meta?: {
                [key: string]: unknown;
            } | null;
            nameservers: string[];
            record_count: number;
            records: {
                [key: string]: unknown;
            }[];
            snapshot_id: string;
            taken_at: string | null;
        } | null;
        seed_snapshot_id: string | null;
        sensitive: boolean;
        state: "pending" | "verified" | "active" | "lapsed" | "revoked" | "expired";
        verified_at: string | null;
    };
}>;
/**
 * DELETE /dns/claims/{id} — Release a claim: it ends (state revoked) and the
 * hosted zone goes out of service, a snapshot of its records kept. Point the
 * domain's nameservers elsewhere first. Gated on the claim's domain
 * (resolved via `getClaim` when a gate is set).
 */
export declare const releaseClaim: (client: Client, id: string) => Promise<{
    claim: {
        activated_at: string | null;
        created_at: string;
        delegation: {
            checked_at: string | null;
            deadline_at: string | null;
            ds_present: boolean;
            lost_at: string | null;
            names: string[];
            ok: boolean;
            partial: boolean;
        };
        domain: string;
        domain_unicode: string;
        end_reason: ("released" | "superseded" | "registered" | "admin" | "not-verified" | "not-delegated" | "delegation-lost" | "grace-expired" | "registry-gone") | null;
        ended_at: string | null;
        expires_at: string | null;
        id: string;
        last_check: {
            ds_present?: boolean;
            error?: string;
            message?: string;
            missing?: string[];
            names?: string[];
            nameserver_count?: number;
            ok: boolean;
            reason?: ("parent-unreachable" | "not-delegated" | "partial" | "delegated-to-ird" | "elsewhere" | "expired" | "activation-refused") | null;
        } | null;
        nameservers: string[];
        registry: {
            checked_at: string | null;
            expires_at: string | null;
            status: {
                [key: string]: unknown;
            } | null;
        };
        seed?: {
            meta?: {
                [key: string]: unknown;
            } | null;
            nameservers: string[];
            record_count: number;
            records: {
                [key: string]: unknown;
            }[];
            snapshot_id: string;
            taken_at: string | null;
        } | null;
        seed_snapshot_id: string | null;
        sensitive: boolean;
        state: "pending" | "verified" | "active" | "lapsed" | "revoked" | "expired";
        verified_at: string | null;
    };
}>;
/**
 * PUT /dns/claims/{id}/seed — Attach a copy of the domain's current records
 * to a pending claim, so the zone ird creates at activation starts from them
 * instead of empty. `snapshot_id` comes from `domains.dnsSnapshot`, taken
 * while the domain still resolves at its previous host. Gated on the
 * claim's domain (resolved via `getClaim` when a gate is set).
 */
export declare const seedClaim: (client: Client, id: string, body: Body<"/dns/claims/{id}/seed", "put">) => Promise<{
    claim: {
        activated_at: string | null;
        created_at: string;
        delegation: {
            checked_at: string | null;
            deadline_at: string | null;
            ds_present: boolean;
            lost_at: string | null;
            names: string[];
            ok: boolean;
            partial: boolean;
        };
        domain: string;
        domain_unicode: string;
        end_reason: ("released" | "superseded" | "registered" | "admin" | "not-verified" | "not-delegated" | "delegation-lost" | "grace-expired" | "registry-gone") | null;
        ended_at: string | null;
        expires_at: string | null;
        id: string;
        last_check: {
            ds_present?: boolean;
            error?: string;
            message?: string;
            missing?: string[];
            names?: string[];
            nameserver_count?: number;
            ok: boolean;
            reason?: ("parent-unreachable" | "not-delegated" | "partial" | "delegated-to-ird" | "elsewhere" | "expired" | "activation-refused") | null;
        } | null;
        nameservers: string[];
        registry: {
            checked_at: string | null;
            expires_at: string | null;
            status: {
                [key: string]: unknown;
            } | null;
        };
        seed?: {
            meta?: {
                [key: string]: unknown;
            } | null;
            nameservers: string[];
            record_count: number;
            records: {
                [key: string]: unknown;
            }[];
            snapshot_id: string;
            taken_at: string | null;
        } | null;
        seed_snapshot_id: string | null;
        sensitive: boolean;
        state: "pending" | "verified" | "active" | "lapsed" | "revoked" | "expired";
        verified_at: string | null;
    };
}>;
/**
 * DELETE /dns/claims/{id}/seed — Drop the attached copy; the zone then
 * starts empty at activation. Gated on the claim's domain (resolved via
 * `getClaim` when a gate is set).
 */
export declare const unseedClaim: (client: Client, id: string) => Promise<{
    claim: {
        activated_at: string | null;
        created_at: string;
        delegation: {
            checked_at: string | null;
            deadline_at: string | null;
            ds_present: boolean;
            lost_at: string | null;
            names: string[];
            ok: boolean;
            partial: boolean;
        };
        domain: string;
        domain_unicode: string;
        end_reason: ("released" | "superseded" | "registered" | "admin" | "not-verified" | "not-delegated" | "delegation-lost" | "grace-expired" | "registry-gone") | null;
        ended_at: string | null;
        expires_at: string | null;
        id: string;
        last_check: {
            ds_present?: boolean;
            error?: string;
            message?: string;
            missing?: string[];
            names?: string[];
            nameserver_count?: number;
            ok: boolean;
            reason?: ("parent-unreachable" | "not-delegated" | "partial" | "delegated-to-ird" | "elsewhere" | "expired" | "activation-refused") | null;
        } | null;
        nameservers: string[];
        registry: {
            checked_at: string | null;
            expires_at: string | null;
            status: {
                [key: string]: unknown;
            } | null;
        };
        seed?: {
            meta?: {
                [key: string]: unknown;
            } | null;
            nameservers: string[];
            record_count: number;
            records: {
                [key: string]: unknown;
            }[];
            snapshot_id: string;
            taken_at: string | null;
        } | null;
        seed_snapshot_id: string | null;
        sensitive: boolean;
        state: "pending" | "verified" | "active" | "lapsed" | "revoked" | "expired";
        verified_at: string | null;
    };
}>;
/**
 * POST /dns/claims/{id}/verify — Read the domain's delegation at its parent
 * zone now and activate the claim when it lists the claim's nameservers.
 * Anything else is not an error: the response is 200 with `check.ok` false
 * and a `reason`.
 */
export declare const verifyClaim: (client: Client, id: string) => Promise<{
    check: {
        ds_present?: boolean;
        error?: string;
        message?: string;
        missing?: string[];
        names?: string[];
        nameserver_count?: number;
        ok: boolean;
        reason?: ("parent-unreachable" | "not-delegated" | "partial" | "delegated-to-ird" | "elsewhere" | "expired" | "activation-refused") | null;
    };
    claim: {
        activated_at: string | null;
        created_at: string;
        delegation: {
            checked_at: string | null;
            deadline_at: string | null;
            ds_present: boolean;
            lost_at: string | null;
            names: string[];
            ok: boolean;
            partial: boolean;
        };
        domain: string;
        domain_unicode: string;
        end_reason: ("released" | "superseded" | "registered" | "admin" | "not-verified" | "not-delegated" | "delegation-lost" | "grace-expired" | "registry-gone") | null;
        ended_at: string | null;
        expires_at: string | null;
        id: string;
        last_check: {
            ds_present?: boolean;
            error?: string;
            message?: string;
            missing?: string[];
            names?: string[];
            nameserver_count?: number;
            ok: boolean;
            reason?: ("parent-unreachable" | "not-delegated" | "partial" | "delegated-to-ird" | "elsewhere" | "expired" | "activation-refused") | null;
        } | null;
        nameservers: string[];
        registry: {
            checked_at: string | null;
            expires_at: string | null;
            status: {
                [key: string]: unknown;
            } | null;
        };
        seed?: {
            meta?: {
                [key: string]: unknown;
            } | null;
            nameservers: string[];
            record_count: number;
            records: {
                [key: string]: unknown;
            }[];
            snapshot_id: string;
            taken_at: string | null;
        } | null;
        seed_snapshot_id: string | null;
        sensitive: boolean;
        state: "pending" | "verified" | "active" | "lapsed" | "revoked" | "expired";
        verified_at: string | null;
    };
}>;