doomain 0.1.0

package/dist/lib/providers/namecheap/index.js

@@ -0,0 +1,289 @@
+import { XMLParser } from 'fast-xml-parser';
+import { normalizeDomain } from '../../validate.js';
+import { ProviderError } from '../core/errors.js';
+import { assertNoConflicts, planDnsChanges } from '../core/planner.js';
+const NAMECHEAP_PRODUCTION_URL = 'https://api.namecheap.com/xml.response';
+const NAMECHEAP_SANDBOX_URL = 'https://api.sandbox.namecheap.com/xml.response';
+const capabilities = {
+    defaultTtl: 1800,
+    recordTypes: ['A', 'AAAA', 'CNAME', 'MX', 'TXT'],
+    supportsApexCname: false,
+    supportsBulkWrites: true,
+    supportsPagination: true,
+    supportsProxying: false,
+    supportsRecordIds: true,
+};
+const parser = new XMLParser({
+    attributeNamePrefix: '',
+    ignoreAttributes: false,
+});
+function asArray(value) {
+    if (value === undefined)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+function bool(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return value === 1;
+    if (typeof value === 'string')
+        return value === '1' || value.toLowerCase() === 'true';
+    return false;
+}
+function getErrorMessage(error) {
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object' && '#text' in error)
+        return String(error['#text']);
+    return JSON.stringify(error);
+}
+function numberValue(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string' && value.trim())
+        return Number(value);
+    return undefined;
+}
+function pagingTotal(commandResponse, result, fallback) {
+    const paging = (commandResponse.Paging ?? result.Paging);
+    return numberValue(paging?.TotalItems) ?? numberValue(paging?.totalItems) ?? fallback;
+}
+function providerCodeFromNamecheapError(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes('clientip') || lower.includes('client ip') || lower.includes('whitelist'))
+        return 'PROVIDER_PERMISSION_DENIED';
+    if (lower.includes('api key') || lower.includes('apiuser') || lower.includes('username') || lower.includes('authentication')) {
+        return 'PROVIDER_AUTH_FAILED';
+    }
+    if (lower.includes('rate'))
+        return 'PROVIDER_RATE_LIMITED';
+    return 'PROVIDER_API_ERROR';
+}
+function namecheapSetupHelp(code) {
+    if (code !== 'PROVIDER_AUTH_FAILED' && code !== 'PROVIDER_PERMISSION_DENIED')
+        return undefined;
+    return 'Make sure API access is enabled and your current public IPv4 is whitelisted at https://ap.www.namecheap.com/settings/tools/apiaccess/.';
+}
+function splitDomain(domain) {
+    const normalized = normalizeDomain(domain);
+    const [sld, ...rest] = normalized.split('.');
+    if (!sld || rest.length === 0)
+        throw new ProviderError('namecheap', 'PROVIDER_ZONE_NOT_FOUND', `Invalid Namecheap domain: ${domain}`);
+    return { sld, tld: rest.join('.') };
+}
+function toZone(domain) {
+    if (!domain.Name)
+        return null;
+    try {
+        const name = normalizeDomain(domain.Name);
+        return { id: name, name };
+    }
+    catch {
+        return null;
+    }
+}
+function toDnsRecord(host) {
+    if (!host.Name || !host.Type || !host.Address)
+        return null;
+    const record = {
+        metadata: { namecheap: host },
+        name: host.Name,
+        type: host.Type,
+        value: host.Address,
+    };
+    if (host.HostId !== undefined)
+        record.id = host.HostId;
+    if (host.MXPref !== undefined)
+        record.priority = Number(host.MXPref);
+    if (host.TTL !== undefined)
+        record.ttl = Number(host.TTL);
+    return record;
+}
+function sameRecord(a, b) {
+    return a.name === b.name && a.type === b.type && a.value === b.value;
+}
+function inputToRecord(record) {
+    return { ...record };
+}
+function hostParams(records) {
+    const params = {};
+    let position = 1;
+    for (const record of records) {
+        params[`HostName${position}`] = record.name;
+        params[`RecordType${position}`] = record.type;
+        params[`Address${position}`] = record.value;
+        params[`TTL${position}`] = String(record.ttl ?? capabilities.defaultTtl);
+        if (record.priority !== undefined)
+            params[`MXPref${position}`] = String(record.priority);
+        position += 1;
+    }
+    return params;
+}
+export class NamecheapProvider {
+    capabilities = capabilities;
+    id = 'namecheap';
+    name = 'Namecheap';
+    apiKey;
+    apiUser;
+    baseUrl;
+    clientIp;
+    username;
+    constructor(context) {
+        this.apiUser = context.credentials.apiUser;
+        this.apiKey = context.credentials.apiKey;
+        this.username = context.credentials.username || context.credentials.apiUser;
+        this.clientIp = context.credentials.clientIp;
+        this.baseUrl = bool(context.credentials.sandbox) ? NAMECHEAP_SANDBOX_URL : NAMECHEAP_PRODUCTION_URL;
+    }
+    async verifyCredentials() {
+        await this.listZones();
+        return { ok: true };
+    }
+    async listZones() {
+        const zones = [];
+        let currentPage = 1;
+        let totalItems = Number.POSITIVE_INFINITY;
+        while (zones.length < totalItems) {
+            const response = await this.request('namecheap.domains.getList', { Page: String(currentPage), PageSize: '100' });
+            const commandResponse = response.ApiResponse.CommandResponse;
+            const result = commandResponse.DomainGetListResult;
+            const domains = asArray(result.Domain);
+            for (const domain of domains) {
+                const zone = toZone(domain);
+                if (zone)
+                    zones.push(zone);
+            }
+            totalItems = pagingTotal(commandResponse, result, zones.length);
+            if (domains.length === 0)
+                break;
+            currentPage += 1;
+        }
+        return zones;
+    }
+    async getZone(domain) {
+        const normalized = normalizeDomain(domain);
+        const zones = await this.listZones();
+        return zones.find((zone) => zone.name === normalized) ?? null;
+    }
+    async listRecords(zone) {
+        const { sld, tld } = splitDomain(zone.name);
+        const response = await this.request('namecheap.domains.dns.getHosts', { SLD: sld, TLD: tld });
+        const hosts = asArray(response.ApiResponse.CommandResponse.DomainDNSGetHostsResult.host);
+        return hosts.flatMap((host) => {
+            const record = toDnsRecord(host);
+            return record ? [record] : [];
+        });
+    }
+    async planChanges(zone, desired, opts = {}) {
+        return planDnsChanges({ desired, existing: await this.listRecords(zone), force: opts.force, providerId: this.id, zone });
+    }
+    async applyChanges(zone, plan) {
+        assertNoConflicts(this.id, plan);
+        const finalRecords = [...plan.existing];
+        const applied = [];
+        const skipped = [];
+        for (const change of plan.changes) {
+            if (change.action === 'skip') {
+                skipped.push(change.record);
+                continue;
+            }
+            if (change.action === 'delete') {
+                const index = finalRecords.findIndex((record) => sameRecord(record, change.existing));
+                if (index !== -1)
+                    finalRecords.splice(index, 1);
+            }
+            else if (change.action === 'update') {
+                const index = finalRecords.findIndex((record) => sameRecord(record, change.existing));
+                if (index !== -1)
+                    finalRecords[index] = { ...change.existing, ...change.record };
+            }
+            else {
+                finalRecords.push(inputToRecord(change.record));
+            }
+            applied.push(change);
+        }
+        if (applied.length > 0)
+            await this.setHosts(zone, finalRecords);
+        return { applied, skipped };
+    }
+    async upsertRecord(zone, record) {
+        const plan = await this.planChanges(zone, [record], { force: true });
+        await this.applyChanges(zone, plan);
+        return { ...record, ttl: record.ttl ?? capabilities.defaultTtl };
+    }
+    async deleteRecord(zone, record) {
+        const records = (await this.listRecords(zone)).filter((item) => !sameRecord(item, record));
+        await this.setHosts(zone, records);
+    }
+    async setHosts(zone, records) {
+        const { sld, tld } = splitDomain(zone.name);
+        const response = await this.request('namecheap.domains.dns.setHosts', { SLD: sld, TLD: tld, ...hostParams(records) }, { method: 'POST' });
+        const result = response.ApiResponse.CommandResponse.DomainDNSSetHostsResult;
+        if (!bool(result?.IsSuccess)) {
+            throw new ProviderError('namecheap', 'PROVIDER_API_ERROR', 'Namecheap did not confirm DNS host records were updated.', result);
+        }
+    }
+    async request(command, params, opts = {}) {
+        if (!this.clientIp) {
+            throw new ProviderError('namecheap', 'MISSING_CREDENTIALS', 'Namecheap requires a whitelisted IPv4 ClientIp credential.');
+        }
+        const query = new URLSearchParams({
+            ApiKey: this.apiKey,
+            ApiUser: this.apiUser,
+            ClientIp: this.clientIp,
+            Command: command,
+            UserName: this.username,
+            ...params,
+        });
+        const method = opts.method ?? 'GET';
+        const response = await fetch(method === 'POST' ? this.baseUrl : `${this.baseUrl}?${query.toString()}`, {
+            ...(method === 'POST'
+                ? { body: query.toString(), headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, method }
+                : {}),
+        });
+        if (!response.ok) {
+            throw new ProviderError('namecheap', 'PROVIDER_API_ERROR', `Namecheap API error (${response.status}).`);
+        }
+        const data = parser.parse(await response.text());
+        const status = data.ApiResponse?.Status;
+        if (status !== 'OK') {
+            const message = getErrorMessage(asArray(data.ApiResponse?.Errors?.Error)[0] ?? 'Namecheap API error.');
+            const code = providerCodeFromNamecheapError(message);
+            const help = namecheapSetupHelp(code);
+            throw new ProviderError('namecheap', code, help ? `${message} ${help}` : message, data.ApiResponse?.Errors);
+        }
+        return data;
+    }
+}
+export const namecheapProviderDefinition = {
+    capabilities,
+    credentials: [
+        { env: 'NAMECHEAP_API_USER', key: 'apiUser', label: 'API user', required: true },
+        { env: 'NAMECHEAP_API_KEY', key: 'apiKey', label: 'API key', required: true, secret: true },
+        { env: 'NAMECHEAP_USERNAME', key: 'username', label: 'Username', required: false },
+        {
+            env: 'NAMECHEAP_CLIENT_IP',
+            hint: 'Must match the IPv4 address whitelisted in Namecheap API Access settings.',
+            key: 'clientIp',
+            label: 'Whitelisted client IP',
+            required: true,
+        },
+        { env: 'NAMECHEAP_SANDBOX', key: 'sandbox', label: 'Use sandbox', required: false },
+    ],
+    displayName: 'Namecheap',
+    docsUrl: 'https://www.namecheap.com/support/api/methods/',
+    id: 'namecheap',
+    name: 'Namecheap',
+    setup: {
+        notes: [
+            'Open Account Dashboard > Profile > Tools > API Access:',
+            'https://ap.www.namecheap.com/settings/tools/apiaccess/',
+            'Enable API access, copy your API key, and add your current public IPv4 to Whitelisted IPs.',
+            'Doomain preserves existing records when updating Namecheap DNS, but Namecheap host writes replace the full host list.',
+        ],
+    },
+    create(context) {
+        return new NamecheapProvider(context);
+    },
+};

package/dist/lib/providers/registry.d.ts

@@ -0,0 +1,4 @@
+import type { DnsProvider, DnsProviderDefinition } from './types.js';
+export declare function listProviderDefinitions(): DnsProviderDefinition[];
+export declare function getProviderDefinition(id: string): DnsProviderDefinition;
+export declare function createProvider(id: string): Promise<DnsProvider>;

package/dist/lib/providers/registry.js

@@ -0,0 +1,21 @@
+import { DoomainError } from '../errors.js';
+import { ensureProviderId } from '../validate.js';
+import { cloudflareProviderDefinition } from './cloudflare/index.js';
+import { createProviderContext } from './core/config.js';
+import { namecheapProviderDefinition } from './namecheap/index.js';
+import { spaceshipProviderDefinition } from './spaceship/index.js';
+const definitions = [spaceshipProviderDefinition, namecheapProviderDefinition, cloudflareProviderDefinition];
+export function listProviderDefinitions() {
+    return definitions;
+}
+export function getProviderDefinition(id) {
+    const providerId = ensureProviderId(id);
+    const definition = definitions.find((provider) => provider.id === providerId);
+    if (!definition)
+        throw new DoomainError('PROVIDER_NOT_FOUND', `Unsupported DNS provider: ${id}`);
+    return definition;
+}
+export async function createProvider(id) {
+    const definition = getProviderDefinition(id);
+    return definition.create(await createProviderContext(definition));
+}

package/dist/lib/providers/spaceship/index.d.ts

@@ -0,0 +1,22 @@
+import type { DnsChangePlan, DnsProvider, DnsProviderDefinition, DnsRecord, DnsRecordInput, DnsZone, ProviderCapabilities, ProviderContext, ProviderHealth } from '../types.js';
+export declare class SpaceshipProvider implements DnsProvider {
+    readonly capabilities: ProviderCapabilities;
+    readonly id = "spaceship";
+    readonly name = "Spaceship";
+    private readonly http;
+    constructor(context: ProviderContext);
+    verifyCredentials(): Promise<ProviderHealth>;
+    listZones(): Promise<DnsZone[]>;
+    getZone(domain: string): Promise<DnsZone | null>;
+    listRecords(zone: DnsZone): Promise<DnsRecord[]>;
+    planChanges(zone: DnsZone, desired: DnsRecordInput[], opts?: {
+        force?: boolean;
+    }): Promise<DnsChangePlan>;
+    applyChanges(zone: DnsZone, plan: DnsChangePlan): Promise<{
+        applied: DnsChangePlan['changes'];
+        skipped: DnsRecordInput[];
+    }>;
+    upsertRecord(zone: DnsZone, record: DnsRecordInput): Promise<DnsRecord>;
+    deleteRecord(zone: DnsZone, record: DnsRecord): Promise<void>;
+}
+export declare const spaceshipProviderDefinition: DnsProviderDefinition;

package/dist/lib/providers/spaceship/index.js

@@ -0,0 +1,148 @@
+import { normalizeDomain } from '../../validate.js';
+import { createProviderHttpClient } from '../core/http.js';
+import { paginateBySkip } from '../core/pagination.js';
+import { applyDnsChanges, planDnsChanges } from '../core/planner.js';
+const SPACESHIP_API_URL = 'https://spaceship.dev/api/v1';
+const capabilities = {
+    defaultTtl: 3600,
+    recordTypes: ['A', 'AAAA', 'CNAME', 'MX', 'TXT'],
+    supportsApexCname: false,
+    supportsBulkWrites: true,
+    supportsPagination: true,
+    supportsProxying: false,
+    supportsRecordIds: false,
+};
+function recordValue(record) {
+    return record.cname ?? record.address ?? record.value ?? '';
+}
+function toSpaceshipItem(record) {
+    const base = {
+        name: record.name,
+        ttl: record.ttl ?? capabilities.defaultTtl,
+        type: record.type,
+    };
+    if (record.type === 'CNAME')
+        return { ...base, cname: record.value };
+    if (record.type === 'A' || record.type === 'AAAA')
+        return { ...base, address: record.value };
+    return { ...base, value: record.value };
+}
+function toDnsRecord(record) {
+    return {
+        name: record.name,
+        ttl: record.ttl,
+        type: record.type,
+        value: recordValue(record),
+    };
+}
+function toZone(domain) {
+    const name = domain.name ?? domain.unicodeName;
+    if (!name)
+        return null;
+    try {
+        const normalized = normalizeDomain(name);
+        return { id: normalized, name: normalized };
+    }
+    catch {
+        return null;
+    }
+}
+export class SpaceshipProvider {
+    capabilities = capabilities;
+    id = 'spaceship';
+    name = 'Spaceship';
+    http;
+    constructor(context) {
+        this.http = createProviderHttpClient({
+            baseUrl: SPACESHIP_API_URL,
+            errorMessages: {
+                401: 'Spaceship rejected the API key/secret. Re-run `doomain providers connect spaceship` with valid credentials.',
+                403: 'Spaceship API key is missing required scopes. Enable domains:read and dnsrecords:read/write.',
+                429: 'Spaceship rate limit exceeded. Try again later.',
+            },
+            headers: {
+                'X-Api-Key': context.credentials.apiKey,
+                'X-Api-Secret': context.credentials.apiSecret,
+            },
+            providerId: this.id,
+            signal: context.signal,
+        });
+    }
+    async verifyCredentials() {
+        await this.listZones();
+        return { ok: true };
+    }
+    async listZones() {
+        const domains = await paginateBySkip({
+            take: 100,
+            fetchPage: ({ skip, take }) => this.http.request('/domains', {
+                query: { orderBy: 'name', skip, take },
+            }),
+        });
+        return domains.flatMap((domain) => {
+            const zone = toZone(domain);
+            return zone ? [zone] : [];
+        });
+    }
+    async getZone(domain) {
+        const normalized = normalizeDomain(domain);
+        const zones = await this.listZones();
+        return zones.find((zone) => zone.name === normalized) ?? null;
+    }
+    async listRecords(zone) {
+        const records = await paginateBySkip({
+            take: 500,
+            fetchPage: ({ skip, take }) => this.http.request(`/dns/records/${zone.name}`, {
+                query: { skip, take },
+            }),
+        });
+        return records.map(toDnsRecord);
+    }
+    async planChanges(zone, desired, opts = {}) {
+        return planDnsChanges({
+            desired,
+            existing: await this.listRecords(zone),
+            force: opts.force,
+            providerId: this.id,
+            zone,
+        });
+    }
+    async applyChanges(zone, plan) {
+        return applyDnsChanges({
+            deleteRecord: (record) => this.deleteRecord(zone, record),
+            plan,
+            providerId: this.id,
+            upsertRecord: (record) => this.upsertRecord(zone, record),
+        });
+    }
+    async upsertRecord(zone, record) {
+        await this.http.request(`/dns/records/${zone.name}`, {
+            body: { force: true, items: [toSpaceshipItem(record)] },
+            method: 'PUT',
+        });
+        return { ...record, ttl: record.ttl ?? capabilities.defaultTtl };
+    }
+    async deleteRecord(zone, record) {
+        await this.http.request(`/dns/records/${zone.name}`, {
+            body: [toSpaceshipItem(record)],
+            method: 'DELETE',
+        });
+    }
+}
+export const spaceshipProviderDefinition = {
+    capabilities,
+    credentials: [
+        { env: 'SPACESHIP_API_KEY', key: 'apiKey', label: 'API key', required: true, secret: true },
+        { env: 'SPACESHIP_API_SECRET', key: 'apiSecret', label: 'API secret', required: true, secret: true },
+    ],
+    displayName: 'Spaceship',
+    docsUrl: 'https://docs.spaceship.dev/',
+    id: 'spaceship',
+    name: 'Spaceship',
+    setup: {
+        notes: ['Create a Spaceship API key with domain and DNS record access before connecting.'],
+    },
+    create(context) {
+        return new SpaceshipProvider(context);
+    },
+};

package/dist/lib/providers/status.d.ts

@@ -0,0 +1,16 @@
+import { type DoomainConfig } from '../config.js';
+import type { DnsProviderDefinition } from './types.js';
+export interface ProviderStatus {
+    configured: boolean;
+    default: boolean;
+    displayName: string;
+    docsUrl?: string;
+    domainCount?: number;
+    error?: string;
+    id: string;
+    verified?: boolean;
+}
+export declare function isProviderConfigured(definition: DnsProviderDefinition, config: DoomainConfig): boolean;
+export declare function listProviderStatuses(opts?: {
+    verify?: boolean;
+}): Promise<ProviderStatus[]>;

package/dist/lib/providers/status.js

@@ -0,0 +1,33 @@
+import { loadConfig } from '../config.js';
+import { getProviderCredential } from './core/config.js';
+import { createProvider, listProviderDefinitions } from './registry.js';
+export function isProviderConfigured(definition, config) {
+    return definition.credentials.every((credential) => credential.required === false || Boolean(getProviderCredential(config, definition.id, credential)));
+}
+export async function listProviderStatuses(opts = {}) {
+    const config = await loadConfig();
+    const statuses = [];
+    for (const definition of listProviderDefinitions()) {
+        const configured = isProviderConfigured(definition, config);
+        const status = {
+            configured,
+            default: config.defaults?.provider === definition.id,
+            displayName: definition.displayName,
+            docsUrl: definition.docsUrl,
+            id: definition.id,
+        };
+        if (configured && opts.verify) {
+            try {
+                const zones = await (await createProvider(definition.id)).listZones();
+                status.domainCount = zones.length;
+                status.verified = true;
+            }
+            catch (error) {
+                status.error = error instanceof Error ? error.message : String(error);
+                status.verified = false;
+            }
+        }
+        statuses.push(status);
+    }
+    return statuses;
+}

package/dist/lib/providers/types.d.ts

@@ -0,0 +1 @@
+export type * from './core/types.js';

package/dist/lib/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/validate.d.ts

@@ -0,0 +1,15 @@
+export interface DomainTarget {
+    zoneDomain: string;
+    fullDomain: string;
+    recordName: string;
+    isApex: boolean;
+}
+export declare function normalizeDomain(input: string): string;
+export declare function normalizeSubdomain(input: string): string;
+export declare function resolveDomainTarget(opts: {
+    domain: string;
+    subdomain?: string;
+    apex?: boolean;
+}): DomainTarget;
+export declare function ensureProviderId(value: string): string;
+export declare function ensureProject(value?: string): string;

package/dist/lib/validate.js

@@ -0,0 +1,62 @@
+import { DoomainError } from './errors.js';
+const DOMAIN_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+export function normalizeDomain(input) {
+    const value = input.trim().toLowerCase().replace(/^https?:\/\//, '').replace(/\/$/, '');
+    const domain = value.split('/')[0];
+    if (!domain || domain.length > 253) {
+        throw new DoomainError('INVALID_INPUT', 'Domain is required.');
+    }
+    const labels = domain.split('.');
+    if (labels.length < 2 || labels.some((label) => !DOMAIN_LABEL.test(label))) {
+        throw new DoomainError('INVALID_INPUT', `Invalid domain: ${input}`);
+    }
+    return domain;
+}
+export function normalizeSubdomain(input) {
+    const subdomain = input.trim().toLowerCase().replace(/^\.+|\.+$/g, '');
+    if (!subdomain || subdomain === '@') {
+        throw new DoomainError('INVALID_INPUT', 'Subdomain is required unless --apex is used.');
+    }
+    const labels = subdomain.split('.');
+    if (labels.some((label) => !DOMAIN_LABEL.test(label))) {
+        throw new DoomainError('INVALID_INPUT', `Invalid subdomain: ${input}`);
+    }
+    return subdomain;
+}
+export function resolveDomainTarget(opts) {
+    const zoneDomain = normalizeDomain(opts.domain);
+    if (opts.apex) {
+        if (opts.subdomain) {
+            throw new DoomainError('INVALID_INPUT', 'Use either --apex or --subdomain, not both.');
+        }
+        return {
+            zoneDomain,
+            fullDomain: zoneDomain,
+            recordName: '@',
+            isApex: true,
+        };
+    }
+    if (!opts.subdomain) {
+        throw new DoomainError('MISSING_ARGUMENT', 'Provide --subdomain or use --apex.');
+    }
+    const subdomain = normalizeSubdomain(opts.subdomain);
+    return {
+        zoneDomain,
+        fullDomain: `${subdomain}.${zoneDomain}`,
+        recordName: subdomain,
+        isApex: false,
+    };
+}
+export function ensureProviderId(value) {
+    const provider = value.trim().toLowerCase();
+    if (!/^[a-z][a-z0-9-]*$/.test(provider)) {
+        throw new DoomainError('INVALID_INPUT', `Invalid provider id: ${value}`);
+    }
+    return provider;
+}
+export function ensureProject(value) {
+    const project = value?.trim();
+    if (!project)
+        throw new DoomainError('MISSING_ARGUMENT', 'Vercel project is required.');
+    return project;
+}

package/dist/lib/vercel.d.ts

@@ -0,0 +1,32 @@
+export declare const VERCEL_APEX_A_RECORD = "76.76.21.21";
+export declare const VERCEL_CNAME_RECORD = "cname.vercel-dns.com";
+export interface VercelProject {
+    id: string;
+    name: string;
+    framework: string | null;
+    updatedAt: number | null;
+}
+export interface VercelTeam {
+    id: string;
+    name: string | null;
+    role: string | null;
+    slug: string;
+}
+export interface VercelConfig {
+    token: string;
+    teamId?: string;
+}
+export declare function resolveVercelConfig(): Promise<VercelConfig>;
+export declare function createVercelClient(config: VercelConfig): {
+    listTeams(): Promise<VercelTeam[]>;
+    listProjects(search?: string): Promise<VercelProject[]>;
+    addDomainToProject(project: string, domain: string): Promise<{
+        alreadyAdded: boolean;
+        raw?: unknown;
+    }>;
+    getDomainConfig(domain: string): Promise<Record<string, unknown>>;
+    getRecommendedCname(domain: string): Promise<string>;
+    getProjectDomain(project: string, domain: string): Promise<Record<string, unknown>>;
+    verifyProjectDomain(project: string, domain: string): Promise<Record<string, unknown>>;
+};
+export type VercelClient = ReturnType<typeof createVercelClient>;