@bctrl/cli 0.1.4 → 0.1.6

package/dist/commands/runtime/index.js

@@ -1,42 +1,55 @@
 import { Command, Option } from 'commander';
 import { readBlob, readJsonFile } from '../shared/io.js';
+import { addPaginationFlags, createOperationJsonBodyCommand, outputFlags, requestOperationAndPrint, uploadOperationFile, } from '../shared/operation.js';
 import { parsePositiveInteger } from '../shared/options.js';
 import { addOutputFlags, outputData } from '../shared/output.js';
-import { addPaginationFlags, createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.js';
+import { CliError } from '../../runtime/errors.js';
 export function createRuntimeCommand(factory) {
     const command = new Command('runtime').description('Manage runtimes');
-    command.addCommand(createListCommand(factory, {
-        description: 'List runtimes',
-        path: '/runtimes',
-        configure: (cmd) => addPaginationFlags(cmd)
-            .option('--space <id>', 'Filter by space id')
-            .option('--status <status>', 'Filter by runtime status'),
-        query: (options) => ({
-            spaceId: typeof options.space === 'string' ? options.space : undefined,
-            status: typeof options.status === 'string' ? options.status : undefined,
-            limit: typeof options.limit === 'number' ? options.limit : undefined,
-            cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
-        }),
+    command.addCommand(addOutputFlags(addPaginationFlags(new Command('list').description('List runtimes'))
+        .option('--space <id>', 'Filter by space id')
+        .addOption(new Option('--status <status>', 'Filter by runtime status').choices([
+        'active',
+        'failed',
+        'stopped',
+    ]))).action(async (options) => {
+        await requestOperationAndPrint(factory, 'runtimes.list', {
+            query: {
+                spaceId: options.space,
+                status: options.status ? [options.status] : undefined,
+                limit: options.limit,
+                cursor: options.cursor,
+            },
+            output: outputFlags(options),
+        });
     }));
-    command.addCommand(createViewCommand(factory, {
-        name: 'get',
-        description: 'Get a runtime',
-        path: '/runtimes/{runtimeId}',
-        argName: 'runtimeId',
+    command.addCommand(addOutputFlags(new Command('get').description('Get a runtime').argument('<runtimeId>')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.get', {
+            pathParams: { runtimeId },
+            output: outputFlags(options),
+        });
     }));
     command.addCommand(createRuntimeCreateCommand(factory));
     command.addCommand(createRuntimePatchCommand(factory));
-    command.addCommand(createDeleteCommand(factory, {
-        description: 'Delete a runtime and its browser state',
-        path: '/runtimes/{runtimeId}',
-        argNames: ['runtimeId'],
-        configure: (cmd) => cmd.option('--force', 'Stop the runtime first if it is still active'),
-        query: (_args, options) => ({ force: options.force === true ? true : undefined }),
+    command.addCommand(addOutputFlags(new Command('delete')
+        .description('Delete a runtime and its browser state')
+        .argument('<runtimeId>')
+        .option('-y, --yes', 'Confirm deletion')
+        .option('--force', 'Stop the runtime first if it is still active')).action(async (runtimeId, options) => {
+        if (options.yes !== true) {
+            throw new CliError('Refusing to delete without --yes');
+        }
+        await requestOperationAndPrint(factory, 'runtimes.delete', {
+            pathParams: { runtimeId },
+            query: { force: options.force === true ? true : undefined },
+            output: outputFlags(options),
+        });
     }));
     command.addCommand(createRuntimeStartCommand(factory));
     command.addCommand(addOutputFlags(new Command('stop').description('Stop a runtime').argument('<runtimeId>')).action(async (runtimeId, options) => {
-        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/stop`, {
-            output: options,
+        await requestOperationAndPrint(factory, 'runtimes.stop', {
+            pathParams: { runtimeId },
+            output: outputFlags(options),
         });
     }));
     command.addCommand(createRuntimeFileCommand(factory));
@@ -47,8 +60,9 @@ export function createRuntimeCommand(factory) {
 function createRuntimeTargetCommand(factory) {
     const command = new Command('target').description('Manage runtime targets (tabs)');
     command.addCommand(addOutputFlags(new Command('list').description('List targets').argument('<runtimeId>')).action(async (runtimeId, options) => {
-        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(runtimeId)}/targets`, {
-            output: options,
+        await requestOperationAndPrint(factory, 'runtimes.targets.list', {
+            pathParams: { runtimeId },
+            output: outputFlags(options),
         });
     }));
     command.addCommand(addOutputFlags(new Command('create')
@@ -56,78 +70,82 @@ function createRuntimeTargetCommand(factory) {
         .argument('<runtimeId>')
         .option('--uri <uri>', 'Navigate the new target to this URI')
         .option('--activate', 'Focus the new target')).action(async (runtimeId, options) => {
-        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/targets`, {
+        await requestOperationAndPrint(factory, 'runtimes.targets.create', {
+            pathParams: { runtimeId },
             body: {
                 ...(options.uri ? { uri: options.uri } : {}),
                 ...(options.activate ? { activate: true } : {}),
             },
-            output: options,
+            output: outputFlags(options),
         });
     }));
     command.addCommand(addOutputFlags(new Command('get').description('Get a target').argument('<runtimeId>').argument('<targetId>')).action(async (runtimeId, targetId, options) => {
-        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(runtimeId)}/targets/${encodeURIComponent(targetId)}`, { output: options });
+        await requestOperationAndPrint(factory, 'runtimes.targets.get', {
+            pathParams: { runtimeId, targetId },
+            output: outputFlags(options),
+        });
     }));
     command.addCommand(addOutputFlags(new Command('activate')
         .description('Focus a target')
         .argument('<runtimeId>')
         .argument('<targetId>')).action(async (runtimeId, targetId, options) => {
-        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/targets/${encodeURIComponent(targetId)}/activate`, { output: options });
+        await requestOperationAndPrint(factory, 'runtimes.targets.activate', {
+            pathParams: { runtimeId, targetId },
+            output: outputFlags(options),
+        });
     }));
     command.addCommand(addOutputFlags(new Command('delete')
         .description('Close a target')
         .argument('<runtimeId>')
         .argument('<targetId>')).action(async (runtimeId, targetId, options) => {
-        await requestAndPrint(factory, 'delete', `/runtimes/${encodeURIComponent(runtimeId)}/targets/${encodeURIComponent(targetId)}`, { output: options });
+        await requestOperationAndPrint(factory, 'runtimes.targets.delete', {
+            pathParams: { runtimeId, targetId },
+            output: outputFlags(options),
+        });
     }));
     return command;
 }
 function createRuntimeCreateCommand(factory) {
-    return createJsonBodyCommand(factory, {
-        name: 'create',
-        description: 'Create a runtime',
-        method: 'post',
-        path: '/runtimes',
-        configure: (cmd) => cmd
-            .option('--space <id>', 'Space id; omitted uses caller default space')
-            .option('--name <name>', 'Runtime name')
-            .option('--profile', 'Persist browser state across runtime starts')
-            .option('--proxy <id-or-url>', 'Saved proxy id or inline custom proxy URL')
-            .addOption(new Option('--device <device>', 'Fingerprint device filter').choices([
-            'desktop',
-            'mobile',
-        ]))
-            .addOption(new Option('--os <os>', 'Fingerprint OS filter').choices([
-            'windows',
-            'macos',
-            'android',
-            'ios',
-        ]))
-            .addOption(new Option('--browser <browser>', 'Fingerprint browser filter').choices([
-            'chrome',
-            'edge',
-            'safari',
-        ]))
-            .option('--browser-version <version>', 'Fingerprint browser version filter')
-            .option('--locale <locale>', 'Fingerprint locale/language filter; repeat to set an ordered language stack', collectLocale, [])
-            .option('--config-file <path>', 'Runtime config JSON file')
-            .option('--metadata-file <path>', 'Runtime metadata JSON file')
-            .option('--input <path>', 'Read full JSON request body from file, or - for stdin'),
-        body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            const config = typeof options.configFile === 'string'
-                ? await readJsonFile(options.configFile, '--config-file')
-                : undefined;
-            return {
-                type: 'browser',
-                spaceId: options.space,
-                name: options.name,
-                config: buildRuntimeCreateConfig(config, options),
-                metadata: typeof options.metadataFile === 'string'
-                    ? await readJsonFile(options.metadataFile, '--metadata-file')
-                    : undefined,
-            };
-        },
+    return addOutputFlags(new Command('create')
+        .description('Create a runtime')
+        .option('--space <id>', 'Space id; omitted uses caller default space')
+        .option('--name <name>', 'Runtime name')
+        .option('--profile', 'Persist browser state across runtime starts')
+        .option('--proxy <id-or-url>', 'Saved proxy id or inline custom proxy URL')
+        .addOption(new Option('--device <device>', 'Fingerprint device filter').choices(['desktop', 'mobile']))
+        .addOption(new Option('--os <os>', 'Fingerprint OS filter').choices([
+        'windows',
+        'macos',
+        'android',
+        'ios',
+    ]))
+        .addOption(new Option('--browser <browser>', 'Fingerprint browser filter').choices([
+        'chrome',
+        'edge',
+        'safari',
+    ]))
+        .option('--browser-version <version>', 'Fingerprint browser version filter')
+        .option('--locale <locale>', 'Fingerprint locale/language filter; repeat to set an ordered language stack', collectLocale, [])
+        .option('--config-file <path>', 'Runtime config JSON file')
+        .option('--metadata-file <path>', 'Runtime metadata JSON file')
+        .option('--input <path>', 'Read full JSON request body from file, or - for stdin')).action(async (options) => {
+        const config = typeof options.configFile === 'string'
+            ? await readJsonFile(options.configFile, '--config-file')
+            : undefined;
+        await requestOperationAndPrint(factory, 'runtimes.create', {
+            body: typeof options.input === 'string'
+                ? (await readJsonFile(options.input))
+                : {
+                    type: 'browser',
+                    spaceId: options.space,
+                    name: options.name,
+                    config: buildRuntimeCreateConfig(config, options),
+                    metadata: typeof options.metadataFile === 'string'
+                        ? await readJsonFile(options.metadataFile, '--metadata-file')
+                        : undefined,
+                },
+            output: outputFlags(options),
+        });
     });
 }
 function collectLocale(value, previous) {
@@ -173,28 +191,26 @@ function buildRuntimeCreateConfig(config, options) {
     };
 }
 function createRuntimePatchCommand(factory) {
-    return createJsonBodyCommand(factory, {
-        name: 'patch',
-        description: 'Update a runtime',
-        method: 'patch',
-        path: '/runtimes/{runtimeId}',
-        argNames: ['runtimeId'],
-        configure: (cmd) => cmd
-            .option('--name <name>', 'Runtime name')
-            .option('--idle-timeout-minutes <minutes>', 'Idle timeout in minutes', parsePositiveInteger)
-            .option('--config-file <path>', 'Runtime config JSON file')
-            .option('--input <path>', 'Read full JSON request body from file, or - for stdin'),
-        body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            return {
-                name: options.name,
-                idleTimeoutMinutes: options.idleTimeoutMinutes,
-                config: typeof options.configFile === 'string'
-                    ? await readJsonFile(options.configFile, '--config-file')
-                    : undefined,
-            };
-        },
+    return addOutputFlags(new Command('patch')
+        .description('Update a runtime')
+        .argument('<runtimeId>')
+        .option('--name <name>', 'Runtime name')
+        .option('--idle-timeout-minutes <minutes>', 'Idle timeout in minutes', parsePositiveInteger)
+        .option('--config-file <path>', 'Runtime config JSON file')
+        .option('--input <path>', 'Read full JSON request body from file, or - for stdin')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.update', {
+            pathParams: { runtimeId },
+            body: typeof options.input === 'string'
+                ? (await readJsonFile(options.input))
+                : {
+                    name: options.name,
+                    idleTimeoutMinutes: options.idleTimeoutMinutes,
+                    config: typeof options.configFile === 'string'
+                        ? await readJsonFile(options.configFile, '--config-file')
+                        : undefined,
+                },
+            output: outputFlags(options),
+        });
     });
 }
 function createRuntimeStartCommand(factory) {
@@ -202,9 +218,10 @@ function createRuntimeStartCommand(factory) {
         .description('Start a runtime')
         .argument('<runtimeId>')
         .option('--idempotency-key <key>', 'Idempotency key for retry-safe start')).action(async (runtimeId, options) => {
-        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/start`, {
+        await requestOperationAndPrint(factory, 'runtimes.start', {
+            pathParams: { runtimeId },
             idempotencyKey: options.idempotencyKey,
-            output: options,
+            output: outputFlags(options),
         });
     });
 }
@@ -216,7 +233,10 @@ function createRuntimeInvocationCommand(factory) {
         .description('Cancel an invocation')
         .argument('<runtimeId>')
         .argument('<invocationId>')).action(async (runtimeId, invocationId, options) => {
-        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/invocations/${encodeURIComponent(invocationId)}/cancel`, { output: options });
+        await requestOperationAndPrint(factory, 'runtimes.invocations.cancel', {
+            pathParams: { runtimeId, invocationId },
+            output: outputFlags(options),
+        });
     }));
     return command;
 }
@@ -248,37 +268,42 @@ function createRuntimeInvocationCreateCommand(factory) {
                 toolsetId: options.toolset,
                 timeoutMs: options.timeoutMs,
             };
-        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/invocations`, {
-            body,
+        await requestOperationAndPrint(factory, 'runtimes.invocations.create', {
+            pathParams: { runtimeId },
+            body: body,
             idempotencyKey: options.idempotencyKey,
-            output: options,
+            output: outputFlags(options),
         });
     });
 }
 function createRuntimeInvocationWaitCommand(factory) {
-    return createJsonBodyCommand(factory, {
+    return createOperationJsonBodyCommand(factory, {
+        operationId: 'runtimes.invocations.wait',
         name: 'wait',
         description: 'Wait for an invocation',
-        method: 'post',
-        path: '/runtimes/{runtimeId}/invocations/{invocationId}/wait',
         argNames: ['runtimeId', 'invocationId'],
         configure: (cmd) => cmd
             .option('--timeout-ms <ms>', 'Wait timeout in milliseconds', parsePositiveInteger)
             .option('--input <path>', 'Read JSON request body from file, or - for stdin'),
         body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
+            if (typeof options.input === 'string') {
+                return (await readJsonFile(options.input));
+            }
             return { timeoutMs: options.timeoutMs };
         },
     });
 }
 function createRuntimeFileCommand(factory) {
     const command = new Command('file').description('Move files into and out of runtimes');
-    command.addCommand(addOutputFlags(addPaginationFlags(new Command('list').description('List runtime files').argument('<runtimeId>'))
-        .option('--type <type>', 'Filter by file type')).action(async (runtimeId, options) => {
-        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(runtimeId)}/files`, {
-            query: { type: options.type, limit: options.limit, cursor: options.cursor },
-            output: options,
+    command.addCommand(addOutputFlags(addPaginationFlags(new Command('list').description('List runtime files').argument('<runtimeId>')).option('--type <type>', 'Filter by file type')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.files.list', {
+            pathParams: { runtimeId },
+            query: {
+                type: options.type,
+                limit: options.limit,
+                cursor: options.cursor,
+            },
+            output: outputFlags(options),
         });
     }));
     command.addCommand(createRuntimeFileUploadCommand(factory));
@@ -295,12 +320,12 @@ function createRuntimeFileUploadCommand(factory) {
         .option('--runtime-path <path>', 'Runtime workspace destination')
         .option('--name <name>', 'Display name')
         .option('--metadata-file <path>', 'Metadata JSON file')).action(async (runtimeId, localPath, options) => {
-        const client = await factory.apiClient();
         const file = await readBlob(localPath);
         const metadata = typeof options.metadataFile === 'string'
             ? JSON.stringify(await readJsonFile(options.metadataFile, '--metadata-file'))
             : undefined;
-        const result = await client.uploadFile(`/runtimes/${encodeURIComponent(runtimeId)}/files/upload`, {
+        const result = await uploadOperationFile(factory, 'runtimes.files.upload', {
+            pathParams: { runtimeId },
             file: file.blob,
             fileName: options.name ?? file.fileName,
             fields: {
@@ -314,11 +339,10 @@ function createRuntimeFileUploadCommand(factory) {
     });
 }
 function createRuntimeFileStageCommand(factory) {
-    return createJsonBodyCommand(factory, {
+    return createOperationJsonBodyCommand(factory, {
+        operationId: 'runtimes.files.stage',
         name: 'stage',
         description: 'Stage a durable file into a runtime',
-        method: 'post',
-        path: '/runtimes/{runtimeId}/files/stage',
         argNames: ['runtimeId'],
         configure: (cmd) => cmd
             .option('--file <id>', 'Durable file id')
@@ -326,18 +350,22 @@ function createRuntimeFileStageCommand(factory) {
             .option('--name <name>', 'Runtime-local display name')
             .option('--input <path>', 'Read JSON request body from file, or - for stdin'),
         body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            return { fileId: options.file, runtimePath: options.runtimePath, name: options.name };
+            if (typeof options.input === 'string') {
+                return (await readJsonFile(options.input));
+            }
+            return {
+                fileId: options.file,
+                runtimePath: options.runtimePath,
+                name: options.name,
+            };
         },
     });
 }
 function createRuntimeFileCollectCommand(factory) {
-    return createJsonBodyCommand(factory, {
+    return createOperationJsonBodyCommand(factory, {
+        operationId: 'runtimes.files.collect',
         name: 'collect',
         description: 'Collect a runtime-local file into durable storage',
-        method: 'post',
-        path: '/runtimes/{runtimeId}/files/collect',
         argNames: ['runtimeId'],
         configure: (cmd) => cmd
             .requiredOption('--runtime-path <path>', 'Runtime workspace source')
@@ -345,8 +373,9 @@ function createRuntimeFileCollectCommand(factory) {
             .option('--destination-path <path>', 'Durable BCTRL storage destination')
             .option('--input <path>', 'Read JSON request body from file, or - for stdin'),
         body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
+            if (typeof options.input === 'string') {
+                return (await readJsonFile(options.input));
+            }
             return {
                 runtimePath: options.runtimePath,
                 name: options.name,

package/dist/commands/shared/help.d.ts

@@ -22,3 +22,4 @@ export type CommandHelpSpec = {
 };
 export declare function addStructuredHelp(command: Command, spec: CommandHelpSpec): Command;
 export declare function addCliHelp(command: Command, commandId: CliHelpCommandId): Command;
+export declare function addCliOperationHelp(command: Command, operationId: string): Command;

package/dist/commands/shared/help.js

@@ -6,6 +6,12 @@ export function addStructuredHelp(command, spec) {
 export function addCliHelp(command, commandId) {
     return addStructuredHelp(command, toCommandHelpSpec(CLI_HELP_COMMANDS[commandId]));
 }
+export function addCliOperationHelp(command, operationId) {
+    return isCliHelpCommandId(operationId) ? addCliHelp(command, operationId) : command;
+}
+function isCliHelpCommandId(value) {
+    return value in CLI_HELP_COMMANDS;
+}
 function toCommandHelpSpec(help) {
     const raw = help;
     return {
@@ -54,11 +60,9 @@ function renderFlags(flags) {
 function renderFields(title, fields) {
     const rows = fields.map((field) => ({
         left: field.name,
-        right: [
-            field.type,
-            field.required === true ? 'required' : 'optional',
-            field.description,
-        ].filter(Boolean).join(' '),
+        right: [field.type, field.required === true ? 'required' : 'optional', field.description]
+            .filter(Boolean)
+            .join(' '),
     }));
     return renderRows(title, rows);
 }

package/dist/commands/shared/operation.d.ts

@@ -0,0 +1,83 @@
+import type { CliOperationId, CliOperationJsonBody, CliOperationPathParams, CliOperationQuery } from '../../openapi.js';
+import { Command } from 'commander';
+import type { BctrlApiClient } from '../../api/client.js';
+import type { IOStreams } from '../../io/streams.js';
+import { type OutputFlags } from './output.js';
+export type ApiDeps = {
+    io: IOStreams;
+    apiClient: () => Promise<BctrlApiClient>;
+};
+type UploadFileInput<OperationId extends CliOperationId> = OperationPathInput<OperationId> & OperationQueryInput<OperationId> & {
+    file: Blob;
+    fileName: string;
+    fields?: Record<string, string>;
+};
+type DownloadInput<OperationId extends CliOperationId> = OperationPathInput<OperationId>;
+type StreamInput<OperationId extends CliOperationId> = OperationPathInput<OperationId> & OperationQueryInput<OperationId>;
+type OperationPathInput<OperationId extends CliOperationId> = [
+    CliOperationPathParams<OperationId>
+] extends [never] ? {
+    pathParams?: never;
+} : {
+    pathParams: CliOperationPathParams<OperationId>;
+};
+type OperationQueryInput<OperationId extends CliOperationId> = [
+    CliOperationQuery<OperationId>
+] extends [never] ? {
+    query?: never;
+} : {
+    query?: CliOperationQuery<OperationId>;
+};
+type OperationBodyInput<OperationId extends CliOperationId> = [
+    CliOperationJsonBody<OperationId>
+] extends [never] ? {
+    body?: never;
+} : {
+    body?: CliOperationJsonBody<OperationId>;
+};
+export type OperationRequestInput<OperationId extends CliOperationId> = OperationPathInput<OperationId> & OperationQueryInput<OperationId> & OperationBodyInput<OperationId> & {
+    idempotencyKey?: string;
+    output?: OutputFlags;
+};
+export declare function addPaginationFlags(command: Command): Command;
+export declare function addJsonBodyFlag(command: Command): Command;
+export declare function outputFlags(options: Record<string, unknown>): OutputFlags;
+export declare function operationPath<OperationId extends CliOperationId>(operationId: OperationId, pathParams?: CliOperationPathParams<OperationId>): string;
+export declare function requestOperationAndPrint<OperationId extends CliOperationId>(deps: ApiDeps, operationId: OperationId, input: OperationRequestInput<OperationId>): Promise<void>;
+export declare function requestOperation<OperationId extends CliOperationId>(deps: ApiDeps, operationId: OperationId, input: OperationRequestInput<OperationId>): Promise<unknown>;
+export declare function uploadOperationFile<OperationId extends CliOperationId>(deps: ApiDeps, operationId: OperationId, input: UploadFileInput<OperationId>): Promise<unknown>;
+export declare function downloadOperation<OperationId extends CliOperationId>(deps: ApiDeps, operationId: OperationId, input: DownloadInput<OperationId>): Promise<Uint8Array>;
+export declare function streamOperationText<OperationId extends CliOperationId>(deps: ApiDeps, operationId: OperationId, input: StreamInput<OperationId>): Promise<AsyncIterable<string>>;
+export declare function createOperationListCommand<OperationId extends CliOperationId>(factory: ApiDeps, config: {
+    operationId: OperationId;
+    name?: string;
+    description: string;
+    configure?: (command: Command) => Command;
+    query?: (options: Record<string, unknown>) => CliOperationQuery<OperationId>;
+}): Command;
+export declare function createOperationViewCommand<OperationId extends CliOperationId>(factory: ApiDeps, config: {
+    operationId: OperationId;
+    name?: string;
+    description: string;
+    argName?: string;
+    configure?: (command: Command) => Command;
+    query?: (id: string, options: Record<string, unknown>) => CliOperationQuery<OperationId>;
+}): Command;
+export declare function createOperationDeleteCommand<OperationId extends CliOperationId>(factory: ApiDeps, config: {
+    operationId: OperationId;
+    name?: string;
+    description: string;
+    argNames?: string[];
+    configure?: (command: Command) => Command;
+    query?: (args: Record<string, string>, options: Record<string, unknown>) => CliOperationQuery<OperationId>;
+}): Command;
+export declare function createOperationJsonBodyCommand<OperationId extends CliOperationId>(factory: ApiDeps, config: {
+    operationId: OperationId;
+    name: string;
+    description: string;
+    argNames?: string[];
+    configure?: (command: Command) => Command;
+    body?: (args: Record<string, string>, options: Record<string, unknown>) => Promise<CliOperationJsonBody<OperationId>>;
+    query?: (args: Record<string, string>, options: Record<string, unknown>) => CliOperationQuery<OperationId>;
+}): Command;
+export {};