doomain 0.1.15 → 0.1.17

package/dist/lib/clerk.d.ts

@@ -0,0 +1,56 @@
+export interface ClerkPlatformConfig {
+    appId: string;
+    platformApiKey: string;
+}
+export interface ClerkApplication {
+    application_id: string;
+    name?: string;
+    instances: Array<{
+        environment_type: string;
+        instance_id: string;
+        publishable_key: string;
+    }>;
+}
+export interface ClerkCnameTarget {
+    host: string;
+    required: boolean;
+    value: string;
+}
+export interface ClerkApplicationDomain {
+    cname_targets?: ClerkCnameTarget[];
+    frontend_api_url: string;
+    id: string;
+    is_satellite: boolean;
+    name: string;
+}
+export interface ClerkProductionInstance {
+    active_domain: ClerkApplicationDomain | null;
+    environment_type: 'production';
+    id: string;
+    publishable_key: string;
+}
+export interface ClerkDomainStatus {
+    dns?: {
+        required?: boolean;
+        status: string;
+    };
+    mail?: {
+        required?: boolean;
+        status: string;
+    };
+    ssl?: {
+        required?: boolean;
+        status: string;
+    };
+    status: string;
+}
+export declare function resolveClerkPlatformConfig(appId?: string): Promise<ClerkPlatformConfig>;
+export declare function createClerkPlatformClient(config: {
+    platformApiKey: string;
+}): {
+    fetchApplication(appId: string): Promise<ClerkApplication>;
+    createProductionInstance(appId: string, domain: string, developmentInstanceId: string): Promise<ClerkProductionInstance>;
+    getDomainStatus(appId: string, domainId: string): Promise<ClerkDomainStatus>;
+    triggerDomainDnsCheck(appId: string, domainId: string): Promise<ClerkDomainStatus>;
+};
+export type ClerkPlatformClient = ReturnType<typeof createClerkPlatformClient>;

package/dist/lib/clerk.js

@@ -0,0 +1,65 @@
+import { loadConfig } from './config.js';
+import { DoomainError } from './errors.js';
+const CLERK_API_URL = 'https://api.clerk.com';
+export async function resolveClerkPlatformConfig(appId) {
+    const config = await loadConfig();
+    const platformApiKey = process.env.CLERK_PLATFORM_API_KEY || config.clerk?.platformApiKey;
+    const resolvedAppId = appId || process.env.CLERK_APPLICATION_ID || config.clerk?.appId;
+    if (!platformApiKey) {
+        throw new DoomainError('MISSING_CREDENTIALS', 'Missing Clerk Platform API key. Run `doomain auth clerk`, set CLERK_PLATFORM_API_KEY, or pass saved credentials.');
+    }
+    if (!platformApiKey.startsWith('ak_')) {
+        throw new DoomainError('INVALID_INPUT', 'Clerk Platform API keys must start with ak_.');
+    }
+    if (!resolvedAppId) {
+        throw new DoomainError('MISSING_ARGUMENT', 'Clerk application is required. Pass --app, set CLERK_APPLICATION_ID, or save it with `doomain auth clerk`.');
+    }
+    return { appId: resolvedAppId, platformApiKey };
+}
+function apiErrorMessage(status, body) {
+    return body?.errors?.[0]?.long_message ?? body?.errors?.[0]?.message ?? body?.error?.message ?? body?.message ?? `Clerk API error (${status}).`;
+}
+function apiErrorCode(body) {
+    return body?.errors?.[0]?.code ?? body?.error?.code ?? body?.code;
+}
+export function createClerkPlatformClient(config) {
+    async function request(path, init = {}) {
+        const response = await fetch(`${CLERK_API_URL}${path}`, {
+            ...init,
+            headers: {
+                Accept: 'application/json',
+                Authorization: `Bearer ${config.platformApiKey}`,
+                ...(init.body ? { 'Content-Type': 'application/json' } : {}),
+                ...(init.headers ?? {}),
+            },
+        });
+        if (!response.ok) {
+            const body = (await response.json().catch(() => undefined));
+            if (response.status === 401 || response.status === 403) {
+                throw new DoomainError('CLERK_AUTH_FAILED', `Clerk Platform API authorization failed. Check CLERK_PLATFORM_API_KEY and its application access. ${apiErrorMessage(response.status, body)}`, body);
+            }
+            if (response.status === 409 && apiErrorCode(body) === 'production_instance_exists') {
+                throw new DoomainError('CLERK_PRODUCTION_EXISTS', 'This Clerk application already has a production instance. Configure domain changes manually in Clerk; Doomain will not modify it.', body);
+            }
+            throw new DoomainError('DOMAIN_LINK_FAILED', apiErrorMessage(response.status, body), body);
+        }
+        return (await response.json());
+    }
+    return {
+        fetchApplication(appId) {
+            return request(`/v1/platform/applications/${encodeURIComponent(appId)}`);
+        },
+        createProductionInstance(appId, domain, developmentInstanceId) {
+            return request(`/v1/platform/applications/${encodeURIComponent(appId)}/instances`, {
+                body: JSON.stringify({ clone_instance_id: developmentInstanceId, domain, environment_type: 'production' }),
+                method: 'POST',
+            });
+        },
+        getDomainStatus(appId, domainId) {
+            return request(`/v1/platform/applications/${encodeURIComponent(appId)}/domains/${encodeURIComponent(domainId)}/status`);
+        },
+        triggerDomainDnsCheck(appId, domainId) {
+            return request(`/v1/platform/applications/${encodeURIComponent(appId)}/domains/${encodeURIComponent(domainId)}/dns_check`, { method: 'POST' });
+        },
+    };
+}

package/dist/lib/command-schema.js

@@ -14,7 +14,7 @@ export const commandSchemas = [
         ],
         agentHint: 'For agent use, try `doomain link <domain> --json` first. Do not inspect project files, run provider status, or use --dry-run unless the user explicitly asks for a preview. The command infers project/provider and returns structured recovery errors when inference fails.',
         agentInstructions: [
-            'When the user asks to add or link a domain, run `doomain link <domain> --json` first.',
+            'When the user asks to add or link a Vercel domain, run `doomain link <domain> --json` first.',
             'Do not run `providers status`, `projects list`, `--help`, or `--dry-run` before the first link attempt unless the user asks for a preview or diagnosis.',
             'Only run follow-up commands when the JSON error includes a recovery action that requires them.',
         ],
@@ -46,6 +46,33 @@ export const commandSchemas = [
             { name: 'timeout', type: 'integer', description: 'Wait timeout in seconds.', default: 300 },
         ],
     },
+    {
+        name: 'clerk domains add',
+        description: 'Create the first Clerk production instance with its primary domain and configure returned DNS records.',
+        examples: [
+            'doomain clerk domains add example.com --app app_123 --json',
+            'doomain clerk domains add example.com --app app_123 --provider cloudflare --no-wait --json',
+            'doomain clerk domains add example.com --app app_123 --dry-run --json',
+        ],
+        agentHint: 'Use only for first-time Clerk production setup. The command aborts with CLERK_PRODUCTION_EXISTS when production already exists; domain changes must then be completed manually in Clerk.',
+        agentInstructions: [
+            'When the user asks to configure a Clerk production domain for the first time, run `doomain clerk domains add <domain> --app <app_id> --json`.',
+            'Never use this command to migrate or replace an existing Clerk production domain.',
+            'After success, follow the returned nextSteps to pull production keys, finish OAuth setup, and verify provisioning with Clerk CLI.',
+        ],
+        mutates: true,
+        safeForAgents: true,
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'app', type: 'string', description: 'Clerk application id. Defaults to CLERK_APPLICATION_ID or saved Clerk config.' },
+            { name: 'provider', type: 'string', description: 'DNS provider id. Inferred from the target domain when omitted.' },
+            { name: 'account', type: 'string', description: 'DNS provider profile/account alias. Defaults to the provider default account.' },
+            { name: 'dry-run', type: 'boolean', description: 'Check application eligibility and DNS zone without creating production.' },
+            { name: 'force', type: 'boolean', description: 'Overwrite DNS records that conflict with Clerk requirements.' },
+            { name: 'wait', type: 'boolean', description: 'Wait for Clerk DNS, SSL, and email DNS verification. Use --no-wait to skip waiting.', default: true },
+            { name: 'timeout', type: 'integer', description: 'Wait timeout in seconds.', default: 300 },
+        ],
+    },
     {
         name: 'schema',
         description: 'Print machine-readable command schemas for agents.',
@@ -132,6 +159,24 @@ export const commandSchemas = [
             { name: 'account', type: 'string', description: 'DNS provider profile/account alias. Defaults to the provider default account.' },
         ],
     },
+    {
+        name: 'auth clerk',
+        description: 'Save and verify Clerk Platform API credentials locally.',
+        examples: ['doomain auth clerk --platform-api-key ak_123 --app app_123 --json', 'doomain auth clerk'],
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'platform-api-key', type: 'string', description: 'Clerk Platform API key (ak_...).' },
+            { name: 'app', type: 'string', description: 'Default Clerk application id.' },
+        ],
+    },
+    {
+        name: 'auth logout clerk',
+        description: 'Remove saved Clerk credentials locally.',
+        examples: ['doomain auth logout clerk --json'],
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+        ],
+    },
     {
         name: 'auth vercel',
         description: 'Save Vercel credentials locally.',
@@ -150,6 +195,23 @@ export const commandSchemas = [
             { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
         ],
     },
+    {
+        name: 'domains find',
+        description: 'Find the configured DNS provider and account for a domain.',
+        examples: [
+            'doomain domains find hacktheandes.com --json',
+            'doomain domains find api.example.com --json',
+            'doomain domains find --domain example.com --provider spaceship --account work --json',
+        ],
+        agentHint: 'Use this command when you need to identify who manages DNS for a domain. It checks all configured provider accounts, tolerates individual provider failures, and selects the longest matching DNS zone. Inspect complete and warnings before treating the result as exhaustive.',
+        safeForAgents: true,
+        flags: [
+            { name: 'json', type: 'boolean', description: 'Output a single JSON object and never prompt.' },
+            { name: 'domain', type: 'string', description: 'Domain to find. May also be passed as the positional argument.' },
+            { name: 'provider', type: 'string', description: 'Limit discovery to one DNS provider id.' },
+            { name: 'account', type: 'string', description: 'Limit discovery to one DNS provider profile/account alias.' },
+        ],
+    },
     {
         name: 'domains list',
         description: 'List DNS zones and records for a provider.',
@@ -204,7 +266,7 @@ async function configuredProviders() {
     }));
 }
 function withProviderConnections(schema, providers) {
-    if (schema.name !== 'link')
+    if (schema.name !== 'link' && schema.name !== 'clerk domains add')
         return schema;
     return { ...schema, configuredProviders: providers };
 }

package/dist/lib/config.d.ts

@@ -6,6 +6,10 @@ export interface VercelConfig {
     token?: string;
     teamId?: string;
 }
+export interface ClerkConfig {
+    appId?: string;
+    platformApiKey?: string;
+}
 export interface ProviderAccountConfig {
     credentials?: Record<string, string>;
     settings?: Record<string, unknown>;
@@ -19,6 +23,7 @@ export interface SpaceshipProviderConfig extends ProviderConfig {
     domains?: string[];
 }
 export interface DoomainConfig {
+    clerk?: ClerkConfig;
     vercel?: VercelConfig;
     providers?: {
         spaceship?: SpaceshipProviderConfig;

package/dist/lib/domain-provider.d.ts

@@ -0,0 +1,53 @@
+import { type DoomainErrorCode } from './errors.js';
+export interface FindDomainProviderInput {
+    account?: string;
+    domain: string;
+    provider?: string;
+}
+export interface ProviderSearchWarning {
+    account: string;
+    error: {
+        code?: DoomainErrorCode;
+        message: string;
+    };
+    isDefaultAccount: boolean;
+    provider: string;
+    providerName: string;
+}
+export interface DomainProviderResult {
+    account: string;
+    accountInferred: boolean;
+    complete: boolean;
+    domain: string;
+    isApex: boolean;
+    isDefaultAccount: boolean;
+    provider: string;
+    providerInferred: boolean;
+    recordName: string;
+    warnings: ProviderSearchWarning[];
+    zoneDomain: string;
+}
+export interface ResolveProviderTargetInput extends FindDomainProviderInput {
+    apex?: boolean;
+    subdomain?: string;
+}
+export interface ResolveProviderTargetOptions {
+    tolerateProviderAccountErrors?: boolean;
+}
+export interface ResolvedDnsTarget {
+    account: string;
+    accountInferred: boolean;
+    isDefaultAccount: boolean;
+    provider: string;
+    providerInferred: boolean;
+    target: {
+        fullDomain: string;
+        isApex: boolean;
+        recordName: string;
+        zoneDomain: string;
+    };
+    warnings: ProviderSearchWarning[];
+}
+export declare function resolveProviderTarget(input: ResolveProviderTargetInput, options?: ResolveProviderTargetOptions): Promise<ResolvedDnsTarget>;
+/** Find the configured DNS provider account with the longest zone match for a domain. */
+export declare function findDomainProvider(input: FindDomainProviderInput): Promise<DomainProviderResult>;

package/dist/lib/domain-provider.js

@@ -0,0 +1,230 @@
+import { loadConfig } from './config.js';
+import { DoomainError } from './errors.js';
+import { DEFAULT_PROVIDER_ACCOUNT, isDefaultProviderAccount, listConfiguredProviderAccounts, normalizeProviderAccount, } from './providers/core/config.js';
+import { createProvider, getProviderDefinition, listProviderDefinitions } from './providers/registry.js';
+import { listProviderStatuses } from './providers/status.js';
+import { normalizeDomain, normalizeSubdomain } from './validate.js';
+function resolveRequestedDomain(opts) {
+    if (opts.apex && opts.subdomain) {
+        throw new DoomainError('INVALID_INPUT', 'Use either --apex or --subdomain, not both.');
+    }
+    const domain = normalizeDomain(opts.domain);
+    if (opts.apex)
+        return { forceExactZone: true, fullDomain: domain };
+    if (!opts.subdomain)
+        return { forceExactZone: false, fullDomain: domain };
+    return { forceExactZone: false, fullDomain: `${normalizeSubdomain(opts.subdomain)}.${domain}` };
+}
+function zoneMatchesDomain(fullDomain, zoneDomain, forceExactZone) {
+    if (fullDomain === zoneDomain)
+        return true;
+    if (forceExactZone)
+        return false;
+    return fullDomain.endsWith(`.${zoneDomain}`);
+}
+function targetFromZone(fullDomain, zoneDomain) {
+    if (fullDomain === zoneDomain) {
+        return { fullDomain, isApex: true, recordName: '@', zoneDomain };
+    }
+    return {
+        fullDomain,
+        isApex: false,
+        recordName: fullDomain.slice(0, -(zoneDomain.length + 1)),
+        zoneDomain,
+    };
+}
+function candidateDetails(candidates) {
+    return candidates.map((candidate) => ({
+        account: candidate.account,
+        isDefaultAccount: candidate.isDefaultAccount,
+        provider: candidate.provider,
+        providerName: candidate.providerName,
+        zoneDomain: candidate.zone.name,
+    }));
+}
+function defaultAccountRef(providerId) {
+    return { account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId };
+}
+function explicitAccountRef(providerId, account) {
+    const normalized = normalizeProviderAccount(account);
+    return { account: normalized, isDefaultAccount: isDefaultProviderAccount(normalized), providerId };
+}
+function searchError(error) {
+    return {
+        ...(error instanceof DoomainError ? { code: error.code } : {}),
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+async function loadProviderZones(definition, account) {
+    const provider = await createProvider(definition.id, { account: account.account });
+    const zones = await provider.listZones();
+    return {
+        candidates: zones.map((zone) => ({
+            account: account.account,
+            isDefaultAccount: account.isDefaultAccount,
+            provider: definition.id,
+            providerName: definition.displayName,
+            zone,
+        })),
+        search: {
+            account: account.account,
+            displayName: definition.displayName,
+            id: definition.id,
+            isDefaultAccount: account.isDefaultAccount,
+            zones: zones.map((zone) => zone.name),
+        },
+    };
+}
+async function loadProviderZonesSafely(definition, account) {
+    try {
+        return await loadProviderZones(definition, account);
+    }
+    catch (error) {
+        return {
+            candidates: [],
+            search: {
+                account: account.account,
+                displayName: definition.displayName,
+                error: searchError(error),
+                id: definition.id,
+                isDefaultAccount: account.isDefaultAccount,
+                zones: [],
+            },
+        };
+    }
+}
+async function providerConnectionDetails() {
+    return (await listProviderStatuses({ verify: false })).map((provider) => ({
+        configured: provider.configured,
+        account: provider.account,
+        default: provider.default,
+        displayName: provider.displayName,
+        docsUrl: provider.docsUrl,
+        id: provider.id,
+        isDefaultAccount: provider.isDefaultAccount,
+    }));
+}
+function searchWarnings(searches) {
+    return searches.flatMap((search) => search.error
+        ? [
+            {
+                account: search.account,
+                error: search.error,
+                isDefaultAccount: search.isDefaultAccount,
+                provider: search.id,
+                providerName: search.displayName,
+            },
+        ]
+        : []);
+}
+async function loadConfiguredProviderZones(providerId, accountInput, tolerateProviderAccountErrors = false) {
+    const config = await loadConfig();
+    const account = accountInput ? normalizeProviderAccount(accountInput) : undefined;
+    if (providerId) {
+        const definition = getProviderDefinition(providerId);
+        const accounts = account ? [explicitAccountRef(definition.id, account)] : listConfiguredProviderAccounts(config, definition);
+        const selectedAccounts = accounts.length > 0 ? accounts : [defaultAccountRef(definition.id)];
+        const tolerateAccountErrors = tolerateProviderAccountErrors && !account && selectedAccounts.length > 1;
+        const results = await Promise.all(selectedAccounts.map((ref) => tolerateAccountErrors ? loadProviderZonesSafely(definition, ref) : loadProviderZones(definition, ref)));
+        return {
+            accountInferred: account === undefined,
+            candidates: results.flatMap((result) => result.candidates),
+            providerInferred: false,
+            searched: results.map((result) => result.search),
+        };
+    }
+    const providerAccounts = listProviderDefinitions().flatMap((definition) => listConfiguredProviderAccounts(config, definition)
+        .filter((ref) => !account || ref.account === account)
+        .map((ref) => ({ definition, ref })));
+    if (providerAccounts.length === 0) {
+        const message = account
+            ? `No DNS provider account named ${account} is configured. Run \`doomain providers connect <provider> --account ${account}\` first.`
+            : 'No DNS provider is configured. Run `doomain providers connect` first.';
+        throw new DoomainError('CONFIG_NOT_FOUND', message, {
+            account,
+            configuredProviders: await providerConnectionDetails(),
+            recovery: 'Connect the DNS provider that owns this domain, then retry `doomain link <domain> --json`.',
+            suggestedCommands: account
+                ? [`doomain providers connect <provider> --account ${account}`, 'doomain link <domain> --json']
+                : ['doomain providers connect', 'doomain link <domain> --json'],
+        });
+    }
+    const results = await Promise.all(providerAccounts.map(({ definition, ref }) => loadProviderZonesSafely(definition, ref)));
+    return {
+        accountInferred: account === undefined,
+        candidates: results.flatMap((result) => result.candidates),
+        providerInferred: true,
+        searched: results.map((result) => result.search),
+    };
+}
+export async function resolveProviderTarget(input, options = {}) {
+    const requested = resolveRequestedDomain(input);
+    const zones = await loadConfiguredProviderZones(input.provider, input.account, options.tolerateProviderAccountErrors);
+    const matches = zones.candidates
+        .filter((candidate) => zoneMatchesDomain(requested.fullDomain, candidate.zone.name, requested.forceExactZone))
+        .sort((a, b) => b.zone.name.length - a.zone.name.length);
+    if (matches.length === 0) {
+        const account = input.account ? normalizeProviderAccount(input.account) : undefined;
+        const providerMessage = input.provider
+            ? `${getProviderDefinition(input.provider).displayName}${account ? ` account ${account}` : ''} does not have a matching DNS zone for ${requested.fullDomain}.`
+            : `No configured DNS provider has a matching DNS zone for ${requested.fullDomain}.`;
+        throw new DoomainError('PROVIDER_ZONE_NOT_FOUND', providerMessage, {
+            account,
+            configuredProviders: await providerConnectionDetails(),
+            domain: requested.fullDomain,
+            recovery: 'Retry with --provider <id> --account <alias> only if another configured provider account owns this zone. Otherwise connect the DNS provider account that owns this domain.',
+            searchedZones: zones.searched,
+            suggestedCommands: [`doomain link ${requested.fullDomain} --provider <id> --account <alias> --json`, 'doomain providers connect'],
+        });
+    }
+    const bestLength = matches[0].zone.name.length;
+    const bestMatches = matches.filter((candidate) => candidate.zone.name.length === bestLength);
+    const uniqueBestMatches = bestMatches.filter((candidate, index, candidates) => candidates.findIndex((item) => item.provider === candidate.provider && item.account === candidate.account && item.zone.name === candidate.zone.name) === index);
+    if (uniqueBestMatches.length > 1) {
+        throw new DoomainError('PROVIDER_ZONE_AMBIGUOUS', `Multiple DNS provider accounts have a matching DNS zone for ${requested.fullDomain}. Pass --provider and --account to choose one.`, { candidates: candidateDetails(uniqueBestMatches), domain: requested.fullDomain });
+    }
+    const selected = uniqueBestMatches[0];
+    return {
+        account: selected.account,
+        accountInferred: zones.accountInferred,
+        isDefaultAccount: selected.isDefaultAccount,
+        provider: selected.provider,
+        providerInferred: zones.providerInferred,
+        target: targetFromZone(requested.fullDomain, selected.zone.name),
+        warnings: searchWarnings(zones.searched),
+    };
+}
+function discoveryError(error, domain) {
+    if (error.code !== 'CONFIG_NOT_FOUND' && error.code !== 'PROVIDER_ZONE_NOT_FOUND')
+        return error;
+    const details = error.details && typeof error.details === 'object' ? error.details : {};
+    return new DoomainError(error.code, error.message, {
+        ...details,
+        recovery: `Connect or repair the DNS provider account that owns this domain, then retry \`doomain domains find ${domain} --json\`.`,
+        suggestedCommands: ['doomain providers connect', `doomain domains find ${domain} --json`],
+    });
+}
+/** Find the configured DNS provider account with the longest zone match for a domain. */
+export async function findDomainProvider(input) {
+    try {
+        const resolved = await resolveProviderTarget(input, { tolerateProviderAccountErrors: true });
+        return {
+            account: resolved.account,
+            accountInferred: resolved.accountInferred,
+            complete: resolved.warnings.length === 0,
+            domain: resolved.target.fullDomain,
+            isApex: resolved.target.isApex,
+            isDefaultAccount: resolved.isDefaultAccount,
+            provider: resolved.provider,
+            providerInferred: resolved.providerInferred,
+            recordName: resolved.target.recordName,
+            warnings: resolved.warnings,
+            zoneDomain: resolved.target.zoneDomain,
+        };
+    }
+    catch (error) {
+        if (error instanceof DoomainError)
+            throw discoveryError(error, input.domain);
+        throw error;
+    }
+}

package/dist/lib/errors.d.ts

@@ -1,4 +1,4 @@
-export type DoomainErrorCode = 'CONFIG_NOT_FOUND' | 'DNS_TARGET_CONFLICT' | 'DOMAIN_LINK_FAILED' | 'DOMAIN_ALREADY_ASSIGNED' | 'DOMAIN_VERIFY_FAILED' | 'INVALID_INPUT' | 'MISSING_ARGUMENT' | 'MISSING_CREDENTIALS' | 'PROVIDER_API_ERROR' | 'PROVIDER_AUTH_FAILED' | 'PROVIDER_PERMISSION_DENIED' | 'PROVIDER_NOT_FOUND' | 'PROVIDER_RATE_LIMITED' | 'PROVIDER_RECORD_CONFLICT' | 'PROVIDER_UNSUPPORTED_RECORD' | 'PROVIDER_ZONE_AMBIGUOUS' | 'PROVIDER_ZONE_NOT_FOUND' | 'PROJECT_NOT_FOUND' | 'VERCEL_AUTH_FAILED' | 'VERCEL_PROJECT_NOT_LINKED';
+export type DoomainErrorCode = 'CONFIG_NOT_FOUND' | 'CLERK_AUTH_FAILED' | 'CLERK_PRODUCTION_EXISTS' | 'DNS_TARGET_CONFLICT' | 'DOMAIN_LINK_FAILED' | 'DOMAIN_PROVIDER_DISCOVERY_FAILED' | 'DOMAIN_ALREADY_ASSIGNED' | 'DOMAIN_VERIFY_FAILED' | 'INVALID_INPUT' | 'MISSING_ARGUMENT' | 'MISSING_CREDENTIALS' | 'PROVIDER_API_ERROR' | 'PROVIDER_AUTH_FAILED' | 'PROVIDER_PERMISSION_DENIED' | 'PROVIDER_NOT_FOUND' | 'PROVIDER_RATE_LIMITED' | 'PROVIDER_RECORD_CONFLICT' | 'PROVIDER_UNSUPPORTED_RECORD' | 'PROVIDER_ZONE_AMBIGUOUS' | 'PROVIDER_ZONE_NOT_FOUND' | 'PROJECT_NOT_FOUND' | 'VERCEL_AUTH_FAILED' | 'VERCEL_PROJECT_NOT_LINKED';
 export declare class DoomainError extends Error {
     readonly code: DoomainErrorCode;
     readonly details?: unknown;

package/dist/lib/link-domain.d.ts

@@ -59,6 +59,7 @@ export interface LinkDomainResult extends LinkDomainPlan {
         verified: boolean;
     };
 }
+export declare function withProviderRecordOptions(provider: string, record: DnsRecordInput): DnsRecordInput;
 export declare function verificationRecords(raw: unknown, zoneDomain: string): DnsRecordInput[];
 export declare function createLinkPlan(input: LinkDomainInput): Promise<LinkDomainPlan>;
 export declare function linkDomain(input: LinkDomainInput): Promise<LinkDomainResult>;