zernio-cli 0.4.0

package/dist/commands/api.js

@@ -0,0 +1,108 @@
+import { openApiInfo } from '../generated/openapi-catalog.js';
+import { parseJsonInput, parseKeyValueList } from '../utils/argument-parsing.js';
+import { prepareApiRequest, runApiRequest } from '../utils/api-request.js';
+import { requireApiKey } from '../utils/config.js';
+import { handleError } from '../utils/errors.js';
+import { endpointSuggestions, endpointToSummary, findEndpoint, listEndpoints, } from '../utils/openapi-catalog.js';
+import { output, outputError } from '../utils/output.js';
+export function registerApiCommands(yargs) {
+    return yargs
+        .command('api:catalog', 'Search the generated OpenAPI endpoint catalog', (y) => y
+        .option('tag', { type: 'string', describe: 'Filter by OpenAPI tag' })
+        .option('method', { type: 'string', describe: 'Filter by HTTP method' })
+        .option('search', { type: 'string', describe: 'Search operation IDs, paths, and summaries' })
+        .option('limit', { type: 'number', describe: 'Maximum endpoints to return', default: 50 }), (argv) => {
+        const endpoints = listEndpoints({
+            tag: argv.tag,
+            method: argv.method,
+            search: argv.search,
+            limit: argv.limit,
+        }).map(endpointToSummary);
+        output({ ...openApiInfo, endpoints }, argv.pretty);
+    })
+        .command('api:describe <operation>', 'Describe one endpoint by operationId or "METHOD /v1/path"', (y) => y.positional('operation', { type: 'string', demandOption: true }), (argv) => {
+        const endpoint = findEndpoint(argv.operation);
+        if (!endpoint) {
+            outputError(`Endpoint not found: ${argv.operation}`, 404);
+        }
+        output(endpoint, argv.pretty);
+    })
+        .command('api:call <operation>', 'Call any Zernio API endpoint from the OpenAPI catalog', (y) => y
+        .positional('operation', { type: 'string', demandOption: true })
+        .option('path', { type: 'array', describe: 'Path param key=value, repeatable' })
+        .option('query', { type: 'array', describe: 'Query param key=value, repeatable' })
+        .option('header', { type: 'array', describe: 'Request header key=value, repeatable' })
+        .option('form', { type: 'array', describe: 'Form field key=value, repeatable' })
+        .option('file', { type: 'array', describe: 'Multipart file key=/path/to/file, repeatable' })
+        .option('body-json', { type: 'string', describe: 'JSON request body string' })
+        .option('body-file', { type: 'string', describe: 'Path to JSON request body file' })
+        .option('raw-body-file', { type: 'string', describe: 'Path to raw request body file' })
+        .option('content-type', { type: 'string', describe: 'Content-Type for JSON, form, or raw body' })
+        .option('request-id', { type: 'string', describe: 'Set x-request-id header for safe retries' })
+        .option('idempotency-key', { type: 'string', describe: 'Set Idempotency-Key header for safe retries' })
+        .option('api-key', { type: 'string', describe: 'API key override; never printed' })
+        .option('base-url', { type: 'string', describe: 'API base URL override' })
+        .option('dry-run', { type: 'boolean', describe: 'Print request preview without sending' }), async (argv) => {
+        try {
+            const endpoint = findEndpoint(argv.operation);
+            if (!endpoint) {
+                outputError(`Endpoint not found: ${argv.operation}`, 404, { suggestions: endpointSuggestions(argv.operation).map(endpointToSummary) }, argv.pretty);
+            }
+            const headers = parseKeyValueList(argv.header);
+            if (argv.requestId)
+                headers['x-request-id'] = String(argv.requestId);
+            if (argv.idempotencyKey)
+                headers['Idempotency-Key'] = String(argv.idempotencyKey);
+            const requestOptions = {
+                apiKey: argv.apiKey,
+                baseUrl: argv.baseUrl,
+                method: endpoint.method,
+                path: endpoint.path,
+                headers,
+                pathParams: parseKeyValueList(argv.path),
+                query: parseKeyValueList(argv.query),
+                form: parseKeyValueList(argv.form),
+                files: parseKeyValueList(argv.file),
+                body: parseJsonInput(argv.bodyJson, argv.bodyFile),
+                rawBodyFile: argv.rawBodyFile,
+                contentType: argv.contentType,
+            };
+            if (!argv.dryRun && !argv.apiKey)
+                requireApiKey();
+            if (argv.dryRun) {
+                const prepared = prepareApiRequest(requestOptions);
+                const headers = prepared.init.headers;
+                output({
+                    ok: true,
+                    dryRun: true,
+                    operation: endpointToSummary(endpoint),
+                    request: {
+                        method: requestOptions.method,
+                        url: prepared.url,
+                        hasAuthorization: headers.has('authorization'),
+                        headers: headersToPreview(headers),
+                        hasBody: prepared.init.body !== undefined,
+                    },
+                }, argv.pretty);
+                return;
+            }
+            const result = await runApiRequest(requestOptions);
+            output(result, argv.pretty);
+            if (!result.ok)
+                process.exit(1);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}
+function headersToPreview(headers) {
+    const preview = {};
+    headers.forEach((value, key) => {
+        preview[key] = isSafeHeaderValue(key) ? value : '<redacted>';
+    });
+    return preview;
+}
+function isSafeHeaderValue(key) {
+    return ['accept', 'content-type'].includes(key.toLowerCase());
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+/** Register auth commands: auth:login, auth:set, auth:check */
+export declare function registerAuthCommands(yargs: Argv): Argv;

package/dist/commands/auth.js

@@ -0,0 +1,138 @@
+import { hostname } from 'os';
+import { getConfig, writeConfig, requireApiKey } from '../utils/config.js';
+import { output, outputError } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+import Late from '@zernio/node';
+/** Default API base URL (without /v1/ suffix, matches SDK default) */
+const DEFAULT_BASE_URL = 'https://zernio.com/api';
+/**
+ * Resolve the base URL for direct fetch calls (not through the SDK).
+ * The SDK adds /v1/ internally, but for auth endpoints we call non-SDK routes
+ * so we need the raw origin (e.g. https://zernio.com).
+ */
+function getApiOrigin() {
+    const config = getConfig();
+    const baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    // Strip trailing /api or /api/ to get the origin
+    return baseUrl.replace(/\/api\/?$/, '');
+}
+/**
+ * Sleep for the given number of milliseconds.
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Register auth commands: auth:login, auth:set, auth:check */
+export function registerAuthCommands(yargs) {
+    return yargs
+        .command('auth:login', 'Log in via browser (device authorization flow)', (y) => y.option('device-name', {
+        type: 'string',
+        describe: 'Device name for the API key label',
+        default: hostname(),
+    }), async (argv) => {
+        const origin = getApiOrigin();
+        const deviceName = argv['device-name'];
+        // Step 1: Initiate the device flow
+        let initiateRes;
+        try {
+            initiateRes = await fetch(`${origin}/api/auth/cli/initiate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ deviceName }),
+            });
+        }
+        catch (err) {
+            outputError(`Failed to connect to ${origin}. Check your internet connection.`);
+        }
+        if (!initiateRes.ok) {
+            const data = await initiateRes.json().catch(() => ({}));
+            outputError(data.error || `Initiation failed (HTTP ${initiateRes.status})`);
+        }
+        const { deviceCode, userCode, browserUrl, expiresAt, interval } = await initiateRes.json();
+        // Step 2: Print instructions to stderr (so stdout stays clean for JSON)
+        process.stderr.write('\n');
+        process.stderr.write(`  Confirmation code: ${userCode}\n\n`);
+        process.stderr.write(`  Opening browser to: ${browserUrl}\n`);
+        process.stderr.write(`  Waiting for authorization...\n\n`);
+        // Step 3: Open browser (dynamic import since 'open' is ESM-only)
+        try {
+            const open = (await import('open')).default;
+            await open(browserUrl);
+        }
+        catch {
+            process.stderr.write(`  Could not open browser automatically.\n  Visit this URL manually: ${browserUrl}\n\n`);
+        }
+        // Step 4: Poll for authorization
+        const pollInterval = (interval || 5) * 1000;
+        const deadline = new Date(expiresAt).getTime();
+        while (Date.now() < deadline) {
+            await sleep(pollInterval);
+            let pollRes;
+            try {
+                pollRes = await fetch(`${origin}/api/auth/cli/poll`, {
+                    headers: { Authorization: `Bearer ${deviceCode}` },
+                });
+            }
+            catch {
+                // Network error, retry on next interval
+                continue;
+            }
+            // Session expired
+            if (pollRes.status === 410) {
+                outputError('Authorization session expired. Run `zernio auth:login` again.');
+            }
+            // Polling too fast (shouldn't happen, but handle gracefully)
+            if (pollRes.status === 429) {
+                continue;
+            }
+            if (!pollRes.ok) {
+                continue;
+            }
+            const data = await pollRes.json();
+            if (data.status === 'authorized' && data.apiKey) {
+                // Save the API key
+                writeConfig({ apiKey: data.apiKey });
+                process.stderr.write('  Authorized! API key saved to ~/.zernio/config.json\n\n');
+                output({ success: true, message: 'Logged in successfully. API key saved.' }, argv.pretty);
+                return;
+            }
+            if (data.status === 'denied') {
+                outputError('Authorization was denied.');
+            }
+            // status === 'pending', keep polling
+        }
+        // Timed out
+        outputError('Authorization timed out. Run `zernio auth:login` again.');
+    })
+        .command('auth:set', 'Save API key to ~/.zernio/config.json', (y) => y
+        .option('key', {
+        type: 'string',
+        describe: 'API key',
+        demandOption: true,
+    })
+        .option('url', {
+        type: 'string',
+        describe: 'Custom API base URL',
+    }), async (argv) => {
+        const updates = { apiKey: argv.key };
+        if (argv.url)
+            updates.baseUrl = argv.url;
+        writeConfig(updates);
+        output({ success: true, message: 'API key saved to ~/.zernio/config.json' }, argv.pretty);
+    })
+        .command('auth:check', 'Verify API key works', (y) => y, async (argv) => {
+        try {
+            const apiKey = requireApiKey();
+            const config = getConfig();
+            const late = new Late({
+                apiKey,
+                baseURL: config.baseUrl || undefined,
+            });
+            const { data } = await late.users.listUsers();
+            output({ success: true, message: 'API key is valid', ...data }, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}

package/dist/commands/automations.d.ts

@@ -0,0 +1,5 @@
+import type { Argv } from 'yargs';
+/**
+ * Register comment-to-DM automation commands: CRUD and logs.
+ */
+export declare function registerAutomationCommands(yargs: Argv): Argv;

package/dist/commands/automations.js

@@ -0,0 +1,139 @@
+import { createClient } from '../client.js';
+import { output } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+/**
+ * Register comment-to-DM automation commands: CRUD and logs.
+ */
+export function registerAutomationCommands(yargs) {
+    return yargs
+        .command('automations:list', 'List comment-to-DM automations', (y) => y
+        .option('profileId', { type: 'string', describe: 'Filter by profile ID' }), async (argv) => {
+        try {
+            const late = createClient();
+            const query = {};
+            if (argv.profileId)
+                query.profileId = argv.profileId;
+            const { data } = await late.commentautomations.listCommentAutomations({ query });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('automations:create', 'Create a comment-to-DM automation', (y) => y
+        .option('profileId', { type: 'string', describe: 'Profile ID', demandOption: true })
+        .option('accountId', { type: 'string', describe: 'Account ID', demandOption: true })
+        .option('platformPostId', { type: 'string', describe: 'Platform-specific post ID', demandOption: true })
+        .option('name', { type: 'string', describe: 'Automation name', demandOption: true })
+        .option('dmMessage', { type: 'string', describe: 'DM message to send', demandOption: true })
+        .option('postId', { type: 'string', describe: 'Zernio post ID (optional)' })
+        .option('postTitle', { type: 'string', describe: 'Post title for display' })
+        .option('keywords', { type: 'string', describe: 'Comma-separated trigger keywords (empty = all comments)' })
+        .option('matchMode', { type: 'string', describe: 'Keyword match mode (exact, contains)', default: 'contains' })
+        .option('commentReply', { type: 'string', describe: 'Optional public comment reply text' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {
+                profileId: argv.profileId,
+                accountId: argv.accountId,
+                platformPostId: argv.platformPostId,
+                name: argv.name,
+                dmMessage: argv.dmMessage,
+                matchMode: argv.matchMode,
+            };
+            if (argv.postId)
+                body.postId = argv.postId;
+            if (argv.postTitle)
+                body.postTitle = argv.postTitle;
+            if (argv.keywords)
+                body.keywords = argv.keywords.split(',').map((s) => s.trim());
+            if (argv.commentReply)
+                body.commentReply = argv.commentReply;
+            const { data } = await late.commentautomations.createCommentAutomation({ body: body });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('automations:get <id>', 'Get automation details with recent logs', (y) => y.positional('id', { type: 'string', describe: 'Automation ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.commentautomations.getCommentAutomation({
+                path: { automationId: argv.id },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('automations:update <id>', 'Update an automation', (y) => y
+        .positional('id', { type: 'string', describe: 'Automation ID', demandOption: true })
+        .option('name', { type: 'string', describe: 'Automation name' })
+        .option('keywords', { type: 'string', describe: 'Comma-separated trigger keywords' })
+        .option('matchMode', { type: 'string', describe: 'Keyword match mode (exact, contains)' })
+        .option('dmMessage', { type: 'string', describe: 'DM message to send' })
+        .option('commentReply', { type: 'string', describe: 'Public comment reply text' })
+        .option('isActive', { type: 'boolean', describe: 'Enable or disable the automation' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {};
+            if (argv.name)
+                body.name = argv.name;
+            if (argv.keywords)
+                body.keywords = argv.keywords.split(',').map((s) => s.trim());
+            if (argv.matchMode)
+                body.matchMode = argv.matchMode;
+            if (argv.dmMessage)
+                body.dmMessage = argv.dmMessage;
+            if (argv.commentReply)
+                body.commentReply = argv.commentReply;
+            if (argv.isActive !== undefined)
+                body.isActive = argv.isActive;
+            const { data } = await late.commentautomations.updateCommentAutomation({
+                path: { automationId: argv.id },
+                body: body,
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('automations:delete <id>', 'Delete an automation and all its logs', (y) => y.positional('id', { type: 'string', describe: 'Automation ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.commentautomations.deleteCommentAutomation({
+                path: { automationId: argv.id },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('automations:logs <id>', 'List trigger logs for an automation', (y) => y
+        .positional('id', { type: 'string', describe: 'Automation ID', demandOption: true })
+        .option('status', { type: 'string', describe: 'Filter by status (sent, failed, skipped)' })
+        .option('limit', { type: 'number', describe: 'Max results', default: 50 })
+        .option('skip', { type: 'number', describe: 'Skip N results', default: 0 }), async (argv) => {
+        try {
+            const late = createClient();
+            const query = {
+                limit: argv.limit,
+                skip: argv.skip,
+            };
+            if (argv.status)
+                query.status = argv.status;
+            const { data } = await late.commentautomations.listCommentAutomationLogs({
+                path: { automationId: argv.id },
+                query,
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}

package/dist/commands/broadcasts.d.ts

@@ -0,0 +1,5 @@
+import type { Argv } from 'yargs';
+/**
+ * Register broadcast commands: CRUD, send, schedule, cancel, recipients.
+ */
+export declare function registerBroadcastCommands(yargs: Argv): Argv;

package/dist/commands/broadcasts.js

@@ -0,0 +1,184 @@
+import { createClient } from '../client.js';
+import { output } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+/**
+ * Register broadcast commands: CRUD, send, schedule, cancel, recipients.
+ */
+export function registerBroadcastCommands(yargs) {
+    return yargs
+        .command('broadcasts:list', 'List broadcasts', (y) => y
+        .option('profileId', { type: 'string', describe: 'Filter by profile ID' })
+        .option('status', { type: 'string', describe: 'Filter by status (draft, scheduled, sending, completed, failed, cancelled)' })
+        .option('platform', { type: 'string', describe: 'Filter by platform' })
+        .option('limit', { type: 'number', describe: 'Max results', default: 20 })
+        .option('skip', { type: 'number', describe: 'Skip N results', default: 0 }), async (argv) => {
+        try {
+            const late = createClient();
+            const query = {
+                limit: argv.limit,
+                skip: argv.skip,
+            };
+            if (argv.profileId)
+                query.profileId = argv.profileId;
+            if (argv.status)
+                query.status = argv.status;
+            if (argv.platform)
+                query.platform = argv.platform;
+            const { data } = await late.broadcasts.listBroadcasts({ query });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('broadcasts:create', 'Create a broadcast draft', (y) => y
+        .option('profileId', { type: 'string', describe: 'Profile ID', demandOption: true })
+        .option('accountId', { type: 'string', describe: 'Account ID', demandOption: true })
+        .option('platform', { type: 'string', describe: 'Platform', demandOption: true })
+        .option('name', { type: 'string', describe: 'Broadcast name', demandOption: true })
+        .option('message', { type: 'string', describe: 'Message text (for non-WhatsApp platforms)' })
+        .option('templateName', { type: 'string', describe: 'WhatsApp template name' })
+        .option('templateLanguage', { type: 'string', describe: 'WhatsApp template language code' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {
+                profileId: argv.profileId,
+                accountId: argv.accountId,
+                platform: argv.platform,
+                name: argv.name,
+            };
+            // WhatsApp uses templates, other platforms use direct messages
+            if (argv.templateName) {
+                body.template = {
+                    name: argv.templateName,
+                    language: argv.templateLanguage || 'en',
+                };
+            }
+            else if (argv.message) {
+                body.message = { text: argv.message };
+            }
+            const { data } = await late.broadcasts.createBroadcast({ body: body });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('broadcasts:get <id>', 'Get broadcast details with stats', (y) => y.positional('id', { type: 'string', describe: 'Broadcast ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.broadcasts.getBroadcast({ path: { broadcastId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('broadcasts:update <id>', 'Update a broadcast (draft only)', (y) => y
+        .positional('id', { type: 'string', describe: 'Broadcast ID', demandOption: true })
+        .option('name', { type: 'string', describe: 'Broadcast name' })
+        .option('message', { type: 'string', describe: 'Message text' }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.broadcasts.updateBroadcast({
+                path: { broadcastId: argv.id },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('broadcasts:delete <id>', 'Delete a broadcast (draft only)', (y) => y.positional('id', { type: 'string', describe: 'Broadcast ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.broadcasts.deleteBroadcast({ path: { broadcastId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('broadcasts:send <id>', 'Send a broadcast immediately', (y) => y.positional('id', { type: 'string', describe: 'Broadcast ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.broadcasts.sendBroadcast({ path: { broadcastId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('broadcasts:schedule <id>', 'Schedule a broadcast for later', (y) => y
+        .positional('id', { type: 'string', describe: 'Broadcast ID', demandOption: true })
+        .option('scheduledAt', { type: 'string', describe: 'ISO 8601 date to send at', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.broadcasts.scheduleBroadcast({
+                path: { broadcastId: argv.id },
+                body: { scheduledAt: argv.scheduledAt },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('broadcasts:cancel <id>', 'Cancel a scheduled or sending broadcast', (y) => y.positional('id', { type: 'string', describe: 'Broadcast ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.broadcasts.cancelBroadcast({ path: { broadcastId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('broadcasts:recipients <id>', 'List broadcast recipients', (y) => y
+        .positional('id', { type: 'string', describe: 'Broadcast ID', demandOption: true })
+        .option('status', { type: 'string', describe: 'Filter by status (pending, sent, delivered, read, failed)' })
+        .option('limit', { type: 'number', describe: 'Max results', default: 50 })
+        .option('skip', { type: 'number', describe: 'Skip N results', default: 0 }), async (argv) => {
+        try {
+            const late = createClient();
+            const query = {
+                limit: argv.limit,
+                skip: argv.skip,
+            };
+            if (argv.status)
+                query.status = argv.status;
+            const { data } = await late.broadcasts.listBroadcastRecipients({
+                path: { broadcastId: argv.id },
+                query,
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('broadcasts:add-recipients <id>', 'Add recipients to a broadcast', (y) => y
+        .positional('id', { type: 'string', describe: 'Broadcast ID', demandOption: true })
+        .option('contactIds', { type: 'string', describe: 'Comma-separated contact IDs' })
+        .option('phones', { type: 'string', describe: 'Comma-separated phone numbers (WhatsApp/Telegram)' })
+        .option('useSegment', { type: 'boolean', describe: 'Use broadcast segment filters to auto-add contacts' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {};
+            if (argv.contactIds)
+                body.contactIds = argv.contactIds.split(',').map((s) => s.trim());
+            if (argv.phones)
+                body.phones = argv.phones.split(',').map((s) => s.trim());
+            if (argv.useSegment)
+                body.useSegment = true;
+            const { data } = await late.broadcasts.addBroadcastRecipients({
+                path: { broadcastId: argv.id },
+                body: body,
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}

package/dist/commands/contacts.d.ts

@@ -0,0 +1,6 @@
+import type { Argv } from 'yargs';
+/**
+ * Register contact commands: contacts:list, contacts:create, contacts:get, contacts:update,
+ * contacts:delete, contacts:channels, contacts:set-field, contacts:clear-field, contacts:bulk-create.
+ */
+export declare function registerContactCommands(yargs: Argv): Argv;