doomain 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Crafter Station LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,293 @@
+# Doomain
+
+Doomain links a Vercel project to a domain from the terminal.
+
+It handles the repetitive parts of shipping a custom domain: finding the right Vercel project, choosing a DNS zone, adding the domain to Vercel, creating the required DNS records, waiting for DNS propagation, and asking Vercel to verify the domain.
+
+Use the interactive wizard when working by hand. Use `--json` when calling Doomain from scripts, CI, or agents.
+
+## Features
+
+- Interactive domain-linking wizard powered by Clack.
+- Non-interactive JSON output for automation and agent workflows.
+- Vercel project detection from `.vercel/project.json`.
+- DNS provider inference by longest matching zone.
+- Dry runs that preview Vercel and DNS changes before writing.
+- DNS propagation and Vercel verification waiting.
+- Built-in Spaceship, Namecheap, and Cloudflare providers.
+
+## Install
+
+```bash
+npm install -g doomain
+```
+
+Doomain requires Node.js 18 or newer.
+
+## Quick Start
+
+Run the wizard:
+
+```bash
+doomain
+```
+
+The wizard prompts for missing credentials, lets you select a Vercel account/team from the token, detects the current Vercel project when possible, lets you connect a DNS provider, lists available domains, previews the changes, and then applies them.
+
+For automation, pass everything explicitly and add `--json`:
+
+```bash
+doomain link app.example.com --project my-app --json
+```
+
+## How It Works
+
+1. Resolve the Vercel account/team, then resolve the project from `--project`, `.vercel/project.json`, or the interactive project selector.
+2. Resolve the target domain from an argument, `--domain`, `--subdomain`, `--apex`, config, or environment variables.
+3. Choose the DNS provider from `--provider` or infer it from configured DNS zones.
+4. Add the domain to the Vercel project.
+5. Read Vercel's recommended target and verification records.
+6. Plan DNS changes against the current provider records.
+7. Apply DNS changes unless `--dry-run` is set.
+8. Wait for public DNS propagation and Vercel verification unless `--no-wait` is set.
+
+## Linking Domains
+
+Link a full domain:
+
+```bash
+doomain link app.example.com --project my-app
+```
+
+Link a subdomain from a base zone:
+
+```bash
+doomain link --domain example.com --subdomain app --project my-app
+```
+
+Link the apex/root domain:
+
+```bash
+doomain link --domain example.com --apex --project my-app
+```
+
+Preview changes without writing to Vercel or DNS:
+
+```bash
+doomain link --provider spaceship --domain example.com --apex --project my-app --dry-run --json
+```
+
+Skip the verification wait:
+
+```bash
+doomain link app.example.com --project my-app --no-wait
+```
+
+Overwrite conflicting DNS records:
+
+```bash
+doomain link app.example.com --project my-app --force
+```
+
+## JSON And Agent Usage
+
+`--json` prints a single JSON object to stdout and never prompts. Use it for scripts, CI, or agent tools.
+
+```bash
+doomain link app.example.com --project my-app --json
+doomain link --domain app.example.com --project my-app --json
+doomain link --domain example.com --subdomain app --project my-app --json
+doomain projects list --json
+doomain providers list --json
+doomain providers status --no-verify --json
+doomain schema --json
+```
+
+When `--provider` is omitted, Doomain searches configured DNS providers and selects the longest matching DNS zone for the target domain. If more than one provider has the same best match, Doomain asks you to pass `--provider` explicitly.
+
+Use the schema command to inspect machine-readable command metadata:
+
+```bash
+doomain schema
+doomain schema link --json
+```
+
+## Credentials
+
+Doomain stores local configuration at:
+
+```bash
+~/.doomain/config.json
+```
+
+The config file is written with `0600` permissions. Environment variables override values in the local config.
+
+### Vercel
+
+```bash
+doomain auth vercel --token vercel_token
+```
+
+Interactive mode fetches Vercel teams from the token and lets you choose a team or your personal account. Use `--team-id` or `VERCEL_TEAM_ID` for non-interactive team-scoped usage.
+
+### Spaceship
+
+```bash
+doomain providers connect spaceship \
+  --credential apiKey=spaceship_key \
+  --credential apiSecret=spaceship_secret
+```
+
+Compatibility aliases are also available:
+
+```bash
+doomain providers connect spaceship --api-key spaceship_key --api-secret spaceship_secret
+```
+
+Spaceship API keys need domain read access and DNS record read/write access.
+
+### Namecheap
+
+```bash
+doomain providers connect namecheap \
+  --credential apiUser=your_namecheap_user \
+  --credential apiKey=your_api_key \
+  --credential clientIp=your_whitelisted_ipv4
+```
+
+For Namecheap sandbox testing:
+
+```bash
+doomain providers connect namecheap \
+  --credential apiUser=your_sandbox_user \
+  --credential apiKey=your_sandbox_key \
+  --credential clientIp=your_whitelisted_ipv4 \
+  --credential sandbox=true
+```
+
+Namecheap API access must be enabled, and `clientIp` must be whitelisted in Namecheap API Access settings.
+
+### Cloudflare
+
+```bash
+doomain providers connect cloudflare \
+  --credential apiToken=your_cloudflare_api_token \
+  --credential accountId=your_cloudflare_account_id
+```
+
+Cloudflare API tokens need `Zone:Read` and `DNS:Edit` permissions for the account. Doomain creates Vercel records as DNS-only records, not proxied records.
+
+## Provider Management
+
+List supported providers:
+
+```bash
+doomain providers list
+```
+
+Interactively add a provider:
+
+```bash
+doomain providers add
+```
+
+Check configured provider health:
+
+```bash
+doomain providers status
+doomain providers status --no-verify --json
+```
+
+Disconnect a saved DNS provider:
+
+```bash
+doomain providers disconnect namecheap
+doomain providers disconnect cloudflare --json
+```
+
+Remove saved Vercel credentials:
+
+```bash
+doomain auth logout vercel
+```
+
+Logout commands remove credentials from `~/.doomain/config.json`. If matching environment variables are still set, they continue to override local config.
+
+Verify one provider's saved credentials:
+
+```bash
+doomain providers verify spaceship
+doomain providers verify namecheap --json
+```
+
+List DNS zones and records:
+
+```bash
+doomain domains list
+doomain domains list --provider cloudflare --domain example.com --json
+```
+
+## Environment Variables
+
+```bash
+VERCEL_TOKEN
+VERCEL_TEAM_ID
+SPACESHIP_API_KEY
+SPACESHIP_API_SECRET
+NAMECHEAP_API_USER
+NAMECHEAP_API_KEY
+NAMECHEAP_USERNAME
+NAMECHEAP_CLIENT_IP
+NAMECHEAP_SANDBOX
+CLOUDFLARE_API_TOKEN
+CLOUDFLARE_ACCOUNT_ID
+DOOMAIN_DOMAIN
+DOOMAIN_PROVIDER
+DOOMAIN_CONFIG_FILE
+```
+
+## Commands
+
+```bash
+doomain                         # interactive wizard
+doomain link                    # link a Vercel project and domain
+doomain auth vercel             # save Vercel credentials
+doomain auth logout vercel      # remove saved Vercel credentials
+doomain providers list          # list supported DNS providers
+doomain providers add           # interactively add a DNS provider
+doomain providers connect       # save provider credentials
+doomain providers disconnect    # remove saved provider credentials
+doomain providers status        # show configured provider health
+doomain providers verify        # verify provider credentials
+doomain domains list            # list DNS zones and records
+doomain projects list           # list Vercel projects
+doomain verify                  # ask Vercel to verify a domain
+doomain schema                  # print command schemas for agents
+```
+
+Run `doomain help <command>` for command-specific flags and examples.
+
+## Provider Notes
+
+Spaceship, Namecheap, and Cloudflare are implemented through a shared DNS provider contract. Each provider declares its credentials and capabilities, then implements zone listing, record listing, change planning, and change application behind the same interface.
+
+Namecheap writes DNS through `setHosts`, which replaces the full host list. Doomain reads all existing records first, applies the planned change in memory, preserves unrelated records, then submits the complete final record set.
+
+Cloudflare supports proxied records generally, but Doomain writes Vercel `A`, `AAAA`, and `CNAME` records with `proxied: false` so Vercel can validate them correctly.
+
+## Development
+
+```bash
+bun install
+bun run build
+bun run test
+```
+
+Useful scripts:
+
+```bash
+bun run lint
+bun run prepack
+```
+
+The package is an oclif CLI. Source lives in `src/commands` and `src/lib`; compiled output is written to `dist`.

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+
+import {execute} from '@oclif/core'
+
+await execute({development: true, dir: import.meta.url})

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import {execute} from '@oclif/core'
+
+const args = process.argv.slice(2)
+const routedArgs = args.length === 0 || (args.length === 1 && args[0] === '--json') ? ['wizard', ...args] : args
+
+await execute({args: routedArgs, dir: import.meta.url})

package/dist/commands/auth/logout/vercel.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class AuthLogoutVercel extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/auth/logout/vercel.js

@@ -0,0 +1,35 @@
+import { Command } from '@oclif/core';
+import { getConfigPath, updateConfig } from '../../../lib/config.js';
+import { jsonFlag } from '../../../lib/flags.js';
+import { createOutput, outputError } from '../../../lib/output.js';
+function envOverrides() {
+    return ['VERCEL_TOKEN', 'VERCEL_TEAM_ID'].filter((key) => process.env[key]);
+}
+export default class AuthLogoutVercel extends Command {
+    static description = 'Remove saved Vercel credentials locally.';
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --json'];
+    static flags = {
+        json: jsonFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(AuthLogoutVercel);
+        const out = createOutput({ json: flags.json });
+        try {
+            let removed = false;
+            await updateConfig((config) => {
+                removed = config.vercel !== undefined;
+                const { vercel: _vercel, ...next } = config;
+                return next;
+            });
+            const overrides = envOverrides();
+            out.result({ configPath: getConfigPath(), environmentOverrides: overrides, removed, service: 'vercel' });
+            if (overrides.length > 0)
+                out.warn(`Vercel environment credentials are still set: ${overrides.join(', ')}.`);
+            out.success(removed ? `Vercel credentials removed from ${getConfigPath()}.` : 'Vercel credentials were not saved.');
+        }
+        catch (error) {
+            outputError(out.json, error, 'MISSING_CREDENTIALS');
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/auth/vercel.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class AuthVercel extends Command {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'team-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/auth/vercel.js

@@ -0,0 +1,69 @@
+import { Command, Flags } from '@oclif/core';
+import * as p from '@clack/prompts';
+import { getConfigPath, maskSecret, updateConfig } from '../../lib/config.js';
+import { jsonFlag } from '../../lib/flags.js';
+import { createOutput, outputError } from '../../lib/output.js';
+import { createVercelClient } from '../../lib/vercel.js';
+const PERSONAL_ACCOUNT = '__personal__';
+function assertValue(value, message) {
+    if (typeof value === 'string' && value.trim())
+        return value.trim();
+    throw new Error(message);
+}
+function teamLabel(team) {
+    const name = team.name ?? team.slug;
+    return `${name} (${team.id})`;
+}
+export default class AuthVercel extends Command {
+    static description = 'Save Vercel credentials locally.';
+    static flags = {
+        json: jsonFlag,
+        'team-id': Flags.string({ description: 'Vercel team id. Interactive mode can fetch and select this from your token.' }),
+        token: Flags.string({ description: 'Vercel API token.' }),
+    };
+    async run() {
+        const { flags } = await this.parse(AuthVercel);
+        const out = createOutput({ json: flags.json });
+        try {
+            let token = flags.token;
+            let teamId = flags['team-id'];
+            if (!out.json && !token) {
+                const value = await p.password({ message: 'Vercel token' });
+                if (p.isCancel(value)) {
+                    p.cancel('Cancelled');
+                    return;
+                }
+                token = value;
+            }
+            token = assertValue(token, 'Missing Vercel token. Pass --token or set VERCEL_TOKEN.');
+            if (!out.json && teamId === undefined) {
+                const spinner = p.spinner();
+                spinner.start('Loading Vercel teams');
+                const teams = await createVercelClient({ token }).listTeams();
+                spinner.stop(`Loaded ${teams.length} Vercel team${teams.length === 1 ? '' : 's'}`);
+                const selected = await p.select({
+                    message: 'Select Vercel account/team',
+                    options: [
+                        { label: 'Personal account', value: PERSONAL_ACCOUNT, hint: 'No team id' },
+                        ...teams.map((team) => ({ label: teamLabel(team), value: team.id, hint: team.role ?? team.slug })),
+                    ],
+                });
+                if (p.isCancel(selected)) {
+                    p.cancel('Cancelled');
+                    return;
+                }
+                teamId = selected === PERSONAL_ACCOUNT ? undefined : selected;
+            }
+            await updateConfig((config) => ({
+                ...config,
+                vercel: { token, teamId },
+            }));
+            out.result({ configPath: getConfigPath(), vercel: { token: maskSecret(token), teamId } });
+            out.success(`Vercel credentials saved to ${getConfigPath()}.`);
+        }
+        catch (error) {
+            outputError(out.json, error, 'MISSING_CREDENTIALS');
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/domains/list.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class DomainsList extends Command {
+    static description: string;
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        provider: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/domains/list.js

@@ -0,0 +1,36 @@
+import { Command } from '@oclif/core';
+import { loadConfig } from '../../lib/config.js';
+import { domainFlag, jsonFlag, providerFlag } from '../../lib/flags.js';
+import { createOutput, outputError } from '../../lib/output.js';
+import { createProvider } from '../../lib/providers/registry.js';
+import { normalizeDomain } from '../../lib/validate.js';
+export default class DomainsList extends Command {
+    static description = 'List DNS zones and records for a provider.';
+    static flags = {
+        domain: domainFlag,
+        json: jsonFlag,
+        provider: providerFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(DomainsList);
+        const out = createOutput({ json: flags.json });
+        try {
+            const config = await loadConfig();
+            const provider = await createProvider(flags.provider ?? process.env.DOOMAIN_PROVIDER ?? config.defaults?.provider ?? 'spaceship');
+            const zones = flags.domain ? [{ id: normalizeDomain(flags.domain), name: normalizeDomain(flags.domain) }] : await provider.listZones();
+            const results = [];
+            for (const zone of zones) {
+                const records = await provider.listRecords(zone);
+                results.push({ zone, records });
+                out.info(`${zone.name} (${records.length} records)`);
+                for (const record of records)
+                    out.info(`  ${record.type} ${record.name} -> ${record.value}`);
+            }
+            out.result({ provider: provider.id, zones: results });
+        }
+        catch (error) {
+            outputError(out.json, error, 'DOMAIN_LINK_FAILED');
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/link.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '@oclif/core';
+export default class Link extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        domain: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        apex: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        provider: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        subdomain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        wait: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/link.js

@@ -0,0 +1,63 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { apexFlag, domainFlag, jsonFlag, projectFlag, providerFlag, subdomainFlag } from '../lib/flags.js';
+import { linkDomain } from '../lib/link-domain.js';
+import { createOutput, outputError } from '../lib/output.js';
+export default class Link extends Command {
+    static description = 'Link a Vercel project to a domain and create DNS records.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> app.example.com --project my-app --json',
+        '<%= config.bin %> <%= command.id %> --domain app.example.com --project my-app --json',
+        '<%= config.bin %> <%= command.id %> --domain example.com --subdomain app --project my-app',
+        '<%= config.bin %> <%= command.id %> --provider spaceship --domain example.com --apex --project my-app --json',
+    ];
+    static args = {
+        domain: Args.string({ description: 'Target domain to link, for example app.example.com.', required: false }),
+    };
+    static flags = {
+        apex: apexFlag,
+        domain: domainFlag,
+        'dry-run': Flags.boolean({ description: 'Preview changes without writing to Vercel or DNS.' }),
+        force: Flags.boolean({ description: 'Overwrite conflicting DNS records.' }),
+        json: jsonFlag,
+        project: projectFlag,
+        provider: providerFlag,
+        subdomain: subdomainFlag,
+        timeout: Flags.integer({ default: 300, description: 'Wait timeout in seconds.' }),
+        wait: Flags.boolean({ allowNo: true, default: true, description: 'Wait for DNS propagation and Vercel verification.' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Link);
+        const out = createOutput({ json: flags.json });
+        let spinner;
+        const domain = flags.domain ?? args.domain;
+        try {
+            if (flags['dry-run']) {
+                const result = await linkDomain({ ...flags, domain, dryRun: true, timeoutSeconds: flags.timeout });
+                out.result(result);
+                if (!out.json)
+                    out.success(`Dry run ready for ${result.domain}.`);
+                return;
+            }
+            out.intro('Doomain');
+            spinner = out.spinner();
+            spinner.start('Linking Vercel project and domain');
+            const result = await linkDomain({
+                ...flags,
+                domain,
+                dryRun: false,
+                progress: out.json ? undefined : ({ message }) => spinner?.message(message),
+                timeoutSeconds: flags.timeout,
+            });
+            spinner.stop(result.vercel.verified ? 'Domain linked and verified' : 'Domain linked');
+            out.result(result);
+            out.outro(result.vercel.verified
+                ? `${result.domain} is linked to ${result.project}. SSL certificate provisioning may take a few minutes in Vercel.`
+                : `${result.domain} is linked to ${result.project}.`);
+        }
+        catch (error) {
+            spinner?.error('Domain link failed');
+            outputError(out.json, error, 'DOMAIN_LINK_FAILED');
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/projects/list.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ProjectsList extends Command {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        search: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/projects/list.js

@@ -0,0 +1,26 @@
+import { Command, Flags } from '@oclif/core';
+import { jsonFlag } from '../../lib/flags.js';
+import { createOutput, outputError } from '../../lib/output.js';
+import { createVercelClient, resolveVercelConfig } from '../../lib/vercel.js';
+export default class ProjectsList extends Command {
+    static description = 'List Vercel projects.';
+    static flags = {
+        json: jsonFlag,
+        search: Flags.string({ description: 'Filter projects by search term.' }),
+    };
+    async run() {
+        const { flags } = await this.parse(ProjectsList);
+        const out = createOutput({ json: flags.json });
+        try {
+            const vercel = createVercelClient(await resolveVercelConfig());
+            const projects = await vercel.listProjects(flags.search);
+            for (const project of projects)
+                out.info(`${project.name} (${project.id})`);
+            out.result({ projects });
+        }
+        catch (error) {
+            outputError(out.json, error, 'PROJECT_NOT_FOUND');
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/providers/add.d.ts

@@ -0,0 +1 @@
+export { default } from './connect.js';

package/dist/commands/providers/add.js

@@ -0,0 +1 @@
+export { default } from './connect.js';

package/dist/commands/providers/connect.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class ProvidersConnect extends Command {
+    static args: {
+        provider: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'api-secret': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        credential: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-verify': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}