@hasna/domains/dist/lib/registrar.d.ts

Domain portfolio, registrar, marketplace, and DNS management for AI agents — CLI + MCP + HTTP API + SDK, shared account API and PostgreSQL

/**
 * Unified registrar provider system
 *
 * Wraps Namecheap and GoDaddy into a common RegistrarProvider interface.
 */
import type { Domain, CreateDomainInput, UpdateDomainInput } from "../db/domains.js";
export interface ProviderDnsRecord {
    type: string;
    name: string;
    value: string;
    ttl: number;
    priority?: number;
    proxied?: boolean;
}
export interface ProviderDomainInfo {
    domain: string;
    registrar: string;
    created: string;
    expires: string;
    nameservers: string[];
    status: string;
    auto_renew: boolean;
}
export interface ProviderRenewResult {
    domain: string;
    success: boolean;
    orderId?: string;
    chargedAmount?: string;
}
export interface ProviderRegistrationContact {
    first_name: string;
    last_name: string;
    email: string;
    phone: string;
    address_line_1: string;
    city: string;
    state: string;
    country_code: string;
    zip_code: string;
    organization_name?: string;
}
export interface ProviderRegistrationOptions {
    years?: number;
    autoRenew?: boolean;
    premiumPrice?: number;
    nameservers?: string[];
    metadata?: Record<string, unknown>;
    privacy?: boolean;
}
export interface ProviderRegistrationResult {
    domain: string;
    success: boolean;
    orderId?: string;
    operationId?: string;
    chargedAmount?: string;
}
export interface ProviderNameserverUpdateResult {
    domain: string;
    success: boolean;
    operationId?: string;
}
export interface ProviderSyncResult {
    synced: number;
    created: number;
    updated: number;
    errors: string[];
}
export interface ProviderAvailability {
    domain: string;
    available: boolean;
    is_premium?: boolean;
    premium_price?: number;
    standard_price?: number;
    currency?: string;
}
export type DbFunctions = {
    getDomainByName: (name: string) => Promise<Domain | null>;
    createDomain: (input: CreateDomainInput) => Promise<Domain>;
    updateDomain: (id: string, input: UpdateDomainInput) => Promise<Domain | null>;
};
/** Handles domain inventory discovery and sync into the local portfolio. */
export interface DomainInventoryProvider {
    name: string;
    listDomains(): Promise<ProviderDomainInfo[]>;
    syncToLocalDb(dbFns: DbFunctions): Promise<ProviderSyncResult>;
}
/** Handles domain registration, renewal, and availability checks */
export interface RegistrarProvider extends DomainInventoryProvider {
    getDomainInfo(domain: string): Promise<ProviderDomainInfo>;
    renewDomain(domain: string, years?: number): Promise<ProviderRenewResult>;
    checkAvailability(domain: string): Promise<ProviderAvailability>;
    registerDomain?(domain: string, contact: ProviderRegistrationContact, options?: ProviderRegistrationOptions): Promise<ProviderRegistrationResult>;
    updateNameservers?(domain: string, nameservers: string[]): Promise<ProviderNameserverUpdateResult>;
}
/** Handles DNS zone and record management */
export type DnsWriteScope = "full-zone" | "changed-groups";
export interface DnsProvider {
    name: string;
    /** Omission is conservative: setDnsRecords receives the complete desired zone. */
    dnsWriteScope?: DnsWriteScope;
    getDnsRecords(domain: string): Promise<ProviderDnsRecord[]>;
    setDnsRecords(domain: string, records: ProviderDnsRecord[]): Promise<boolean>;
    /**
     * Delete the EXACT live records matching the given records.
     *
     * Omission is conservative: `dns apply` refuses a delete plan
     * (`delete-apply-unsupported`) unless the provider can converge on deletes through
     * this route, so a non-deletable provider is never written into a partial state.
     */
    deleteDnsRecords?(domain: string, records: ProviderDnsRecord[]): Promise<boolean>;
}
/** A provider that does both — e.g. Route 53 */
export type FullProvider = RegistrarProvider & DnsProvider;
export interface ProviderInfo {
    name: string;
    type: "registrar" | "dns" | "full" | "marketplace";
    configured: boolean;
    inventory?: boolean;
    envVars: string[];
}
export interface SyncAllResult {
    providers: {
        name: string;
        result: ProviderSyncResult;
    }[];
    totalSynced: number;
    totalErrors: string[];
}
interface RegistryEntry {
    info: ProviderInfo;
    createInventory?: () => DomainInventoryProvider;
    createRegistrar?: () => RegistrarProvider;
    createDns?: () => DnsProvider;
}
export declare function registerProvider(entry: RegistryEntry): void;
export declare function getAvailableProviders(): ProviderInfo[];
export declare function getProviderInfo(name: string): ProviderInfo | null;
export declare function providerHasRegistrar(name: string): boolean;
export declare function providerHasDns(name: string): boolean;
export declare function providerHasInventory(name: string): boolean;
export declare function getDomainInventoryProvider(name: string): DomainInventoryProvider;
export declare function getRegistrarProvider(name: string): RegistrarProvider;
export declare function getDnsProvider(name: string): DnsProvider;
/** @deprecated Use getRegistrarProvider() */
export declare function getProvider(name: string): RegistrarProvider;
export declare function syncAll(dbFns: DbFunctions): Promise<SyncAllResult>;
export declare function autoDetectRegistrar(domain: string, getDomainByName: (name: string) => Promise<Domain | null>): Promise<string | null>;
export {};
//# sourceMappingURL=registrar.d.ts.map