@myapihq/cli 1.0.84 → 1.1.0-wip.1

package/dist/commands/auth.d.ts

@@ -1,3 +1,8 @@
-export declare function link(flags?: Record<string, string | boolean>, emailArg?: string): Promise<void>;
-export declare function whoami(flags?: Record<string, string | boolean>): Promise<void>;
-export declare function switchCmd(flags?: Record<string, string | boolean>, indexArg?: string): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import type { Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare const HELP = "Usage: myapi auth <subcommand>\n\nSubcommands:\n  setup           Configure your account\n  import-key      Import an existing API key non-interactively\n  whoami          Show current account \u00B7 supports --json\n  link [email]    Upgrade anonymous account to registered (or add a second session)\n                  Use myapi auth setup to create a completely new account\n  switch [index]  Switch active account by index or email\n  config          Manage CLI defaults (org, funnel, domain) \u00B7 supports set-org / set-funnel / set-domain\n  install-skills  Install or update the MyAPI skills pack for AI agents\n  api-keys        Manage API keys \u00B7 list / create / revoke\n  keys            Alias for api-keys";
+export declare const INSTALL_SKILLS_HELP = "Usage: myapi auth install-skills\n\nInstalls the MyAPI skills pack for AI coding agents (Claude, Gemini, Cursor).\n\nThis command writes skill definition files to:\n  ~/.agents/skills/myapi/\n\nAnd creates symlinks in the appropriate agent config directories:\n  ~/.claude/  (Claude)\n  ~/.gemini/  (Gemini)\n  ~/.cursor/  (Cursor, if detected)\n\nThese files teach agents how to use the MyAPI CLI and API directly.\nRun this command again to update existing skills to the latest version.";
+export declare function link(flags?: Flags, emailArg?: string): Promise<void>;
+export declare function whoami(flags?: Flags): Promise<void>;
+export declare function switchCmd(flags?: Flags, indexArg?: string): Promise<void>;

package/dist/commands/auth.js

@@ -1,47 +1,83 @@
-import * as readline from 'readline';
 import { loadConfig, saveConfig, addAccount, switchAccount, listAccounts } from '../config.js';
 import { info, success, error, printJson } from '../output.js';
+import { ask, confirm, withReadline } from '../prompt.js';
 import { installSkills } from './setup.js';
 import { hq } from '@myapihq/sdk';
-const API_BASE = process.env.MYAPI_API_BASE ?? 'https://api.myapihq.com';
-function ask(rl, q) {
-    return new Promise(resolve => rl.question(q, resolve));
-}
-function yn(answer, defaultYes = true) {
-    const t = answer.trim().toLowerCase();
-    if (t === '')
-        return defaultYes;
-    return t === 'y' || t === 'yes';
-}
-async function post(path, body, apiKey) {
-    const headers = { 'Content-Type': 'application/json' };
-    if (apiKey)
-        headers['Authorization'] = `Bearer ${apiKey}`;
-    const res = await fetch(`${API_BASE}${path}`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(body),
-    });
-    const json = await res.json();
-    if (!res.ok)
-        throw new Error(json.error ?? `HTTP ${res.status}`);
-    return json.data ?? json;
-}
-async function patch(path, body, apiKey) {
-    const res = await fetch(`${API_BASE}${path}`, {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
-        body: JSON.stringify(body),
-    });
-    const json = await res.json();
-    if (!res.ok)
-        throw new Error(json.error ?? `HTTP ${res.status}`);
-    return json.data ?? json;
+export const SCHEMA = {
+    'install-skills': 'boolean',
+    'no-skills': 'boolean',
+    anonymous: 'boolean',
+    anon: 'boolean',
+};
+export const HELP = `Usage: myapi auth <subcommand>
+
+Subcommands:
+  setup           Configure your account
+  import-key      Import an existing API key non-interactively
+  whoami          Show current account · supports --json
+  link [email]    Upgrade anonymous account to registered (or add a second session)
+                  Use myapi auth setup to create a completely new account
+  switch [index]  Switch active account by index or email
+  config          Manage CLI defaults (org, funnel, domain) · supports set-org / set-funnel / set-domain
+  install-skills  Install or update the MyAPI skills pack for AI agents
+  api-keys        Manage API keys · list / create / revoke
+  keys            Alias for api-keys`;
+export const INSTALL_SKILLS_HELP = `Usage: myapi auth install-skills
+
+Installs the MyAPI skills pack for AI coding agents (Claude, Gemini, Cursor).
+
+This command writes skill definition files to:
+  ~/.agents/skills/myapi/
+
+And creates symlinks in the appropriate agent config directories:
+  ~/.claude/  (Claude)
+  ~/.gemini/  (Gemini)
+  ~/.cursor/  (Cursor, if detected)
+
+These files teach agents how to use the MyAPI CLI and API directly.
+Run this command again to update existing skills to the latest version.`;
+const LINK_HELP = `Usage: myapi auth link [email]
+
+Behavior depends on whether the email is new or already registered:
+
+  New email:        Attaches it to your current anonymous account, upgrading it
+                    to a registered account. A one-time code is sent to confirm.
+
+  Existing email:   Does NOT merge accounts. The existing account is added as a
+                    second active session — your anonymous account stays separate.
+                    Switch between sessions with: myapi auth switch
+
+To create a completely new account from scratch, use: myapi auth setup`;
+const WHOAMI_HELP = `Usage: myapi auth whoami [--json]
+
+Displays the active account details: email, account ID, default org,
+default funnel, account type, and current balance.
+
+Flags:
+  --json   Output raw JSON`;
+const SWITCH_HELP = `Usage: myapi auth switch [index|email]
+
+Switches the active account. Run without arguments to see a numbered list
+of accounts and choose interactively.
+
+Pass an index number or email address to switch non-interactively:
+  myapi auth switch 2
+  myapi auth switch you@example.com
+
+Note: index numbers can shift as accounts are added or removed.
+Use email as a stable identifier in scripts.`;
+// Resolve the user's "install skills?" preference: explicit flag wins, else prompt.
+async function resolveSkillsPreference(flags) {
+    if (flags['install-skills'])
+        return true;
+    if (flags['no-skills'])
+        return false;
+    return confirm('› Install the MyAPI skills pack? (Y/n) ', true);
 }
 // myapi auth link — upgrade anonymous session to registered account.
 export async function link(flags = {}, emailArg) {
     if (flags.help) {
-        info('Usage: myapi auth link [email]\n\nBehavior depends on whether the email is new or already registered:\n\n  New email:        Attaches it to your current anonymous account, upgrading it\n                    to a registered account. A one-time code is sent to confirm.\n\n  Existing email:   Does NOT merge accounts. The existing account is added as a\n                    second active session — your anonymous account stays separate.\n                    Switch between sessions with: myapi auth switch\n\nTo create a completely new account from scratch, use: myapi auth setup');
+        info(LINK_HELP);
         return;
     }
     const config = loadConfig();
@@ -49,14 +85,13 @@ export async function link(flags = {}, emailArg) {
         error('Not configured. Run: myapi auth setup');
     if (!config.is_anonymous)
         error('Already registered. Use your existing account.');
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const email = emailArg || (await ask(rl, '› Email? ')).trim();
+    await withReadline(async () => {
+        const email = emailArg || await ask('› Email? ');
         if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email))
             error(`Invalid email address: "${email}".`);
         let upgradeOk = true;
         try {
-            await patch('/hq/account/upgrade', { email }, config.api_key);
+            await hq.upgradeAccount(config.api_key, email);
         }
         catch (err) {
             if (err.message !== 'EMAIL_TAKEN')
@@ -64,16 +99,14 @@ export async function link(flags = {}, emailArg) {
             upgradeOk = false;
             info(`› That email already has an account — accounts cannot be merged.`);
             info(`› Your anonymous account will be kept and you can switch back to it anytime.`);
-            const ans = (await ask(rl, '› Sign in and add it as a second account? (Y/n) ')).trim();
-            if (!yn(ans))
+            if (!await confirm('› Sign in and add it as a second account? (Y/n) ', true))
                 return;
-            await post('/hq/account/send-code', { email });
+            await hq.sendCode(email);
         }
         info(`› Sent a code to ${email} · paste it below`);
-        const code = (await ask(rl, '› Code? ')).trim();
-        const data = await post('/hq/account/verify-code', { email, code });
-        const skillsFromFlag = flags['install-skills'] ? true : flags['no-skills'] ? false : null;
-        const wantsSkills = skillsFromFlag !== null ? skillsFromFlag : yn((await ask(rl, '› Install the MyAPI skills pack? (Y/n) ')).trim());
+        const code = await ask('› Code? ');
+        const data = await hq.verifyCode(email, code);
+        const wantsSkills = await resolveSkillsPreference(flags);
         if (upgradeOk) {
             saveConfig({
                 ...config,
@@ -102,15 +135,12 @@ export async function link(flags = {}, emailArg) {
         }
         if (wantsSkills)
             await installSkills();
-    }
-    finally {
-        rl.close();
-    }
+    });
 }
 // myapi auth whoami — show current session info.
 export async function whoami(flags = {}) {
     if (flags.help) {
-        info('Usage: myapi auth whoami [--json]\n\nDisplays the active account details: email, account ID, default org, default funnel, account type, and current balance.\n\nFlags:\n  --json   Output raw JSON');
+        info(WHOAMI_HELP);
         return;
     }
     const config = loadConfig();
@@ -144,7 +174,7 @@ export async function whoami(flags = {}) {
 // myapi auth switch [index] — switch between saved accounts.
 export async function switchCmd(flags = {}, indexArg) {
     if (flags.help) {
-        info('Usage: myapi auth switch [index|email]\n\nSwitches the active account. Run without arguments to see a numbered list\nof accounts and choose interactively.\n\nPass an index number or email address to switch non-interactively:\n  myapi auth switch 2\n  myapi auth switch you@example.com\n\nNote: index numbers can shift as accounts are added or removed.\nUse email as a stable identifier in scripts.');
+        info(SWITCH_HELP);
         return;
     }
     const accounts = listAccounts();
@@ -163,13 +193,7 @@ export async function switchCmd(flags = {}, indexArg) {
     }
     let idxStr = indexArg ?? '';
     if (!idxStr) {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        try {
-            idxStr = (await ask(rl, `› Switch to account (1-${accounts.length})? `)).trim();
-        }
-        finally {
-            rl.close();
-        }
+        idxStr = await ask(`› Switch to account (1-${accounts.length})? `);
     }
     // Support email as a stable identifier
     let idx;

package/dist/commands/billing.d.ts

@@ -1,4 +1,8 @@
-export declare function balance(flags: Record<string, string | boolean>): Promise<void>;
-export declare function history(flags: Record<string, string | boolean>): Promise<void>;
-export declare function topup(amountStr: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function setup(flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import type { Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;
+export declare function balance(flags: Flags): Promise<void>;
+export declare function history(flags: Flags): Promise<void>;
+export declare function topup(amountStr: string, flags: Flags): Promise<void>;
+export declare function setup(_flags: Flags): Promise<void>;

package/dist/commands/billing.js

@@ -1,13 +1,48 @@
-import * as readline from 'readline';
 import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
+import { confirm } from '../prompt.js';
 import { formatDate } from '../utils.js';
-export async function balance(flags) {
+export const SCHEMA = {};
+const SUBCOMMAND_USAGE = {
+    'balance': 'myapi billing balance [--json]',
+    'history': 'myapi billing history [--json]',
+    'topup': `myapi billing topup <amount> [--yes]
+
+Amount is in whole dollars (e.g. "10" charges $10).
+Confirmation is required for amounts of $50 or more — pass --yes to skip it.
+
+Example: myapi billing topup 10`,
+    'setup': 'myapi billing setup',
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi billing <subcommand>
+
+Subcommands:
+  balance    Check balance, credits, and payment method status
+  history    View recent transactions and top-ups
+  topup      Top up your balance (whole dollars)
+  setup      Open a checkout link to add or update payment method`);
+        return;
+    }
     if (flags.help) {
-        info('Usage: myapi billing balance [--json]\n\nShows your current account balance, credits, and payment method status.\n\nFlags:\n  --json   Output raw JSON');
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi billing --help" for the list.`);
         return;
     }
+    switch (subcommand) {
+        case 'balance': return balance(flags);
+        case 'history': return history(flags);
+        case 'topup': return topup(args[0], flags);
+        case 'setup': return setup(flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi billing --help" for available subcommands.`);
+    }
+}
+export async function balance(flags) {
     const config = requireConfig();
     const result = await hq.getBalance(config.api_key);
     if (flags.json) {
@@ -24,43 +59,31 @@ export async function balance(flags) {
     info(`Balance: ${result.balance_display}  |  Credits: ${result.credits_display} (not usable for domains)  |  Payment method: ${pm}`);
 }
 export async function history(flags) {
-    if (flags.help) {
-        info('Usage: myapi billing history [--json]\n\nShows your recent billing transactions and top-ups.\n\nFlags:\n  --json   Output raw JSON');
-        return;
-    }
     const config = requireConfig();
     const items = await hq.getBillingHistory(config.api_key);
     if (flags.json) {
         printJson(items);
         return;
     }
-    if (items.length === 0) {
-        info('No transactions yet.');
-        return;
-    }
     const formattedItems = items.map(item => ({
         Type: item.type || 'unknown',
         Amount: item.amount_display,
         Status: item.status ? item.status.charAt(0).toUpperCase() + item.status.slice(1) : '',
         Date: formatDate(item.created_at),
     }));
-    printTable(formattedItems);
+    printTable(formattedItems, {
+        flags,
+        empty: 'No transactions yet.',
+    });
 }
 export async function topup(amountStr, flags) {
-    if (flags.help) {
-        info('Usage: myapi billing topup <amount>\n\nAmount is in whole dollars (e.g. "10" charges $10).\nConfirmation is required for amounts of $50 or more. Use --yes to skip it.\nExample: myapi billing topup 10\n\nFlags:\n  --yes   Skip confirmation prompt for large amounts');
-        return;
-    }
     const amount = Math.round(parseFloat(amountStr));
     if (!amountStr || isNaN(amount) || amount <= 0) {
-        error("Amount must be a positive whole number of dollars (e.g. myapi billing topup 10)");
-        return;
+        error('Amount must be a positive whole number of dollars (e.g. myapi billing topup 10)');
     }
     if (!flags.yes && !flags.y && amount >= 50) {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        const ans = await new Promise(resolve => rl.question(`› Charge $${amount} to your saved payment method? (y/N) `, resolve));
-        rl.close();
-        if (ans.trim().toLowerCase() !== 'y' && ans.trim().toLowerCase() !== 'yes') {
+        const ok = await confirm(`› Charge $${amount} to your saved payment method? (y/N) `, false);
+        if (!ok) {
             info('Cancelled.');
             return;
         }
@@ -69,11 +92,7 @@ export async function topup(amountStr, flags) {
     const result = await hq.topUp(config.api_key, amount);
     success(`Top up successful! New balance: ${result.new_balance_display}`);
 }
-export async function setup(flags) {
-    if (flags.help) {
-        info('Usage: myapi billing setup\n\nGenerates a secure checkout link to add or update your payment method.');
-        return;
-    }
+export async function setup(_flags) {
     const config = requireConfig();
     const result = await hq.setupPayment(config.api_key);
     success(`Open this URL in your browser to set up payment:\n${result.url}`);

package/dist/commands/config.d.ts

@@ -1,5 +1,8 @@
-export declare function setOrg(id: string, flags: Record<string, string | boolean>, via?: string): Promise<void>;
-export declare function setFunnel(id: string, flags: Record<string, string | boolean>, via?: string): Promise<void>;
-export declare function setDomain(domain: string, flags: Record<string, string | boolean>, via?: string): Promise<void>;
-export declare function view(flags: Record<string, string | boolean>, via?: string): Promise<void>;
-export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import type { Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function setOrg(id: string, _flags: Flags, via?: string): Promise<void>;
+export declare function setFunnel(id: string, _flags: Flags, via?: string): Promise<void>;
+export declare function setDomain(domain: string, _flags: Flags, via?: string): Promise<void>;
+export declare function view(flags: Flags, _via?: string): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/config.js

@@ -1,10 +1,13 @@
 import { hq, funnel as sdkFunnel } from '@myapihq/sdk';
 import { requireConfig, saveConfig } from '../config.js';
-import { success, error, info } from '../output.js';
+import { success, error, info, printJson } from '../output.js';
+export const SCHEMA = {
+    _via: 'string',
+};
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-export async function setOrg(id, flags, via = 'auth config') {
-    if (!id || flags.help) {
-        info(`Usage: myapi ${via} set-org <id>\n\nSets the default organization for all commands that require --org.\nThe ID is validated against the API before saving.\n\nExample:\n  myapi ${via} set-org xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`);
+export async function setOrg(id, _flags, via = 'auth config') {
+    if (!id) {
+        info(`Usage: myapi ${via} set-org <id>`);
         return;
     }
     if (!UUID_RE.test(id))
@@ -16,9 +19,9 @@ export async function setOrg(id, flags, via = 'auth config') {
     saveConfig(config);
     success(`Default organization set to: ${org.name || org.id}`);
 }
-export async function setFunnel(id, flags, via = 'auth config') {
-    if (!id || flags.help) {
-        info(`Usage: myapi ${via} set-funnel <id>\n\nSets the default funnel. The funnel must belong to your current default org.\nThe ID is validated against the API before saving.\n\nExample:\n  myapi ${via} set-funnel xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`);
+export async function setFunnel(id, _flags, via = 'auth config') {
+    if (!id) {
+        info(`Usage: myapi ${via} set-funnel <id>`);
         return;
     }
     if (!UUID_RE.test(id))
@@ -34,9 +37,9 @@ export async function setFunnel(id, flags, via = 'auth config') {
     saveConfig(config);
     success(`Default funnel set to: ${funnelId}`);
 }
-export async function setDomain(domain, flags, via = 'auth config') {
-    if (!domain || flags.help) {
-        info(`Usage: myapi ${via} set-domain <domain>\n\nSets the default domain used by domain commands when the domain argument is omitted.\n\nExample:\n  myapi ${via} set-domain example.com`);
+export async function setDomain(domain, _flags, via = 'auth config') {
+    if (!domain) {
+        info(`Usage: myapi ${via} set-domain <domain>`);
         return;
     }
     const config = requireConfig();
@@ -44,14 +47,9 @@ export async function setDomain(domain, flags, via = 'auth config') {
     saveConfig(config);
     success(`Default domain set to: ${domain}`);
 }
-export async function view(flags, via = 'auth config') {
-    if (flags.help) {
-        info(`Usage: myapi ${via} view [--json]\n\nShows the currently configured defaults: default org, funnel, and domain.\n\nFlags:\n  --json   Output raw JSON`);
-        return;
-    }
+export async function view(flags, _via = 'auth config') {
     const config = requireConfig();
     if (flags.json) {
-        const { printJson } = await import('../output.js');
         printJson({
             default_org: config.default_org ?? null,
             default_funnel: config.default_funnel ?? null,
@@ -63,20 +61,47 @@ export async function view(flags, via = 'auth config') {
     info(`Default Funnel: ${config.default_funnel || 'Not set'}`);
     info(`Default Domain: ${config.default_domain || 'Not set'}`);
 }
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+function subcommandUsage(via) {
+    return {
+        'view': `myapi ${via} view [--json]`,
+        'set-org': `myapi ${via} set-org <id>\n\nSets the default organization for all commands that require --org.\nThe ID is validated against the API before saving.`,
+        'set-funnel': `myapi ${via} set-funnel <id>\n\nSets the default funnel. Must belong to your current default org.\nThe ID is validated against the API before saving.`,
+        'set-domain': `myapi ${via} set-domain <domain>\n\nSets the default domain used by domain commands when the domain arg is omitted.`,
+    };
+}
 export async function run(subcommand, args, flags) {
     const via = flags._via || 'auth config';
     if (!subcommand || (flags.help && !subcommand)) {
-        info(`Usage: myapi ${via} <subcommand>\n\nManages CLI defaults (org, funnel, domain) so you don't have to pass --org / --domain on every command.\n\nSubcommands:\n  view         Show current defaults\n  set-org      Set default organization (validates access)\n  set-funnel   Set default funnel (must be owned by default org)\n  set-domain   Set default domain\n\nExamples:\n  myapi auth config set-org <id>\n  myapi auth config set-funnel <id>\n  myapi auth config view`);
+        info(`Usage: myapi ${via} <subcommand>
+
+Manages CLI defaults (org, funnel, domain) so you don't have to pass --org / --domain on every command.
+
+Subcommands:
+  view         Show current defaults
+  set-org      Set default organization (validates access)
+  set-funnel   Set default funnel (must be owned by default org)
+  set-domain   Set default domain
+
+Examples:
+  myapi ${via} set-org <id>
+  myapi ${via} set-funnel <id>
+  myapi ${via} view`);
         return;
     }
-    if (subcommand === 'view')
-        await view(flags, via);
-    else if (subcommand === 'set-org')
-        await setOrg(args[0], flags, via);
-    else if (subcommand === 'set-funnel')
-        await setFunnel(args[0], flags, via);
-    else if (subcommand === 'set-domain')
-        await setDomain(args[0], flags, via);
-    else
-        error(`Unknown subcommand: ${subcommand}. Run "myapi config --help" for a list of valid subcommands.`);
+    if (flags.help) {
+        const usage = subcommandUsage(via)[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi ${via} --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'view': return view(flags, via);
+        case 'set-org': return setOrg(args[0], flags, via);
+        case 'set-funnel': return setFunnel(args[0], flags, via);
+        case 'set-domain': return setDomain(args[0], flags, via);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi ${via} --help" for a list of valid subcommands.`);
+    }
 }

package/dist/commands/domain.d.ts

@@ -1,9 +1,12 @@
-export declare function check(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function register(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function list(flags: Record<string, string | boolean>): Promise<void>;
-export declare function assign(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function unassign(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function status(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function settings(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function updateSettings(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import { type Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function check(domainArg: string, flags: Flags): Promise<void>;
+export declare function register(domainArg: string, flags: Flags): Promise<void>;
+export declare function list(flags: Flags): Promise<void>;
+export declare function assign(domainArg: string, flags: Flags): Promise<void>;
+export declare function unassign(domainArg: string, flags: Flags): Promise<void>;
+export declare function status(domainArg: string, flags: Flags): Promise<void>;
+export declare function settings(domainArg: string, flags: Flags): Promise<void>;
+export declare function updateSettings(domainArg: string, flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;