@bctrl/cli 0.1.3 → 0.1.5

package/dist/commands/runtime/index.js

@@ -1,161 +1,386 @@
-import { Command } from 'commander';
-import { CliError } from '../../runtime/errors.js';
-import { addCliHelp } from '../shared/help.js';
-import { readBlob, readJsonFile, writeBinary } from '../shared/io.js';
+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, createJsonBodyCommand, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.js';
+import { CliError } from '../../runtime/errors.js';
 export function createRuntimeCommand(factory) {
-    const command = new Command('runtime').description('Create, start, stop, and manage BCTRL 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,
-        }),
+    const command = new Command('runtime').description('Manage runtimes');
+    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,
+                limit: options.limit,
+                cursor: options.cursor,
+            },
+            output: outputFlags(options),
+        });
     }));
-    command.addCommand(createViewCommand(factory, {
-        description: 'View a runtime',
-        path: '/runtimes/{id}',
+    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(addCliHelp(createJsonBodyCommand(factory, {
-        name: 'create',
-        description: 'Create a runtime',
-        method: 'post',
-        path: '/runtimes',
-        configure: (cmd) => cmd
-            .option('--space <id>', 'Space id')
-            .option('--name <name>', 'Runtime name')
-            .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);
-            if (typeof options.space !== 'string' || options.space.length === 0) {
-                throw new CliError('runtime create requires --space unless --input is used');
-            }
-            return {
-                type: 'browser',
-                spaceId: options.space,
-                name: options.name,
-                config: typeof options.configFile === 'string'
-                    ? await readJsonFile(options.configFile, '--config-file')
-                    : undefined,
-                metadata: typeof options.metadataFile === 'string'
-                    ? await readJsonFile(options.metadataFile, '--metadata-file')
-                    : undefined,
-            };
-        },
-    }), 'runtime.create'));
-    command.addCommand(addCliHelp(addOutputFlags(new Command('start').description('Start a runtime').argument('<id>')).action(async (id, options) => {
-        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(id)}/start`, {
-            output: options,
+    command.addCommand(createRuntimeCreateCommand(factory));
+    command.addCommand(createRuntimePatchCommand(factory));
+    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),
         });
-    }), 'runtime.start'));
-    command.addCommand(addOutputFlags(new Command('stop').description('Stop a runtime').argument('<id>')).action(async (id, options) => {
-        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(id)}/stop`, {
-            output: options,
+    }));
+    command.addCommand(createRuntimeStartCommand(factory));
+    command.addCommand(addOutputFlags(new Command('stop').description('Stop a runtime').argument('<runtimeId>')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.stop', {
+            pathParams: { runtimeId },
+            output: outputFlags(options),
         });
     }));
     command.addCommand(createRuntimeFileCommand(factory));
-    command.addCommand(addOutputFlags(new Command('runs')
-        .description('List runs for a runtime')
-        .argument('<id>')
-        .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger)
-        .option('--cursor <cursor>', 'Pagination cursor')).action(async (id, options) => {
-        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(id)}/runs`, {
-            query: { limit: options.limit, cursor: options.cursor },
-            output: options,
+    command.addCommand(createRuntimeInvocationCommand(factory));
+    command.addCommand(createRuntimeTargetCommand(factory));
+    return command;
+}
+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 requestOperationAndPrint(factory, 'runtimes.targets.list', {
+            pathParams: { runtimeId },
+            output: outputFlags(options),
+        });
+    }));
+    command.addCommand(addOutputFlags(new Command('create')
+        .description('Open a new target')
+        .argument('<runtimeId>')
+        .option('--uri <uri>', 'Navigate the new target to this URI')
+        .option('--activate', 'Focus the new target')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.targets.create', {
+            pathParams: { runtimeId },
+            body: {
+                ...(options.uri ? { uri: options.uri } : {}),
+                ...(options.activate ? { activate: true } : {}),
+            },
+            output: outputFlags(options),
+        });
+    }));
+    command.addCommand(addOutputFlags(new Command('get').description('Get a target').argument('<runtimeId>').argument('<targetId>')).action(async (runtimeId, targetId, 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 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 requestOperationAndPrint(factory, 'runtimes.targets.delete', {
+            pathParams: { runtimeId, targetId },
+            output: outputFlags(options),
         });
     }));
     return command;
 }
+function createRuntimeCreateCommand(factory) {
+    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) {
+    return [...previous, value];
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function buildRuntimeCreateConfig(config, options) {
+    const fingerprint = {
+        ...(options.device ? { device: options.device } : {}),
+        ...(options.os ? { os: options.os } : {}),
+        ...(options.browser ? { browser: options.browser } : {}),
+        ...(options.browserVersion ? { browserVersion: options.browserVersion } : {}),
+        ...(options.locale && options.locale.length === 1 ? { locale: options.locale[0] } : {}),
+        ...(options.locale && options.locale.length > 1 ? { locale: options.locale } : {}),
+    };
+    const overrides = {
+        ...(options.profile === true ? { profile: true } : {}),
+        ...(options.proxy ? { proxy: options.proxy } : {}),
+        ...(Object.keys(fingerprint).length > 0 ? { fingerprint } : {}),
+    };
+    if (Object.keys(overrides).length === 0) {
+        return config;
+    }
+    if (config !== undefined && !isRecord(config)) {
+        throw new Error('--config-file must contain a JSON object when combined with runtime flags');
+    }
+    if (!isRecord(config)) {
+        return overrides;
+    }
+    return {
+        ...config,
+        ...overrides,
+        ...(isRecord(config.fingerprint) || 'fingerprint' in overrides
+            ? {
+                fingerprint: {
+                    ...(isRecord(config.fingerprint) ? config.fingerprint : {}),
+                    ...(isRecord(overrides.fingerprint) ? overrides.fingerprint : {}),
+                },
+            }
+            : {}),
+    };
+}
+function createRuntimePatchCommand(factory) {
+    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) {
+    return addOutputFlags(new Command('start')
+        .description('Start a runtime')
+        .argument('<runtimeId>')
+        .option('--idempotency-key <key>', 'Idempotency key for retry-safe start')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.start', {
+            pathParams: { runtimeId },
+            idempotencyKey: options.idempotencyKey,
+            output: outputFlags(options),
+        });
+    });
+}
+function createRuntimeInvocationCommand(factory) {
+    const command = new Command('invocation').description('Create, wait for, and cancel invocations');
+    command.addCommand(createRuntimeInvocationCreateCommand(factory));
+    command.addCommand(createRuntimeInvocationWaitCommand(factory));
+    command.addCommand(addOutputFlags(new Command('cancel')
+        .description('Cancel an invocation')
+        .argument('<runtimeId>')
+        .argument('<invocationId>')).action(async (runtimeId, invocationId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.invocations.cancel', {
+            pathParams: { runtimeId, invocationId },
+            output: outputFlags(options),
+        });
+    }));
+    return command;
+}
+function createRuntimeInvocationCreateCommand(factory) {
+    return addOutputFlags(new Command('create')
+        .description('Create a runtime invocation')
+        .argument('<runtimeId>')
+        .option('--action <action>', 'Invocation action')
+        .option('--instruction <text>', 'Instruction for action/agent invocations')
+        .option('--target <target>', "Target to act on: 'active' (default), 'new', or a target id")
+        .option('--model <model>', 'Model id')
+        .option('--tool <id...>', 'Inline tool id')
+        .option('--toolset <id>', 'Toolset id')
+        .option('--timeout-ms <ms>', 'Invocation timeout in milliseconds', parsePositiveInteger)
+        .option('--idempotency-key <key>', 'Idempotency key for retry-safe create')
+        .option('--input <path>', 'Read full JSON request body from file, or - for stdin')).action(async (runtimeId, options) => {
+        const body = typeof options.input === 'string'
+            ? await readJsonFile(options.input)
+            : {
+                action: options.action,
+                instruction: options.instruction,
+                target: options.target === undefined
+                    ? undefined
+                    : options.target === 'active' || options.target === 'new'
+                        ? options.target
+                        : { id: options.target },
+                model: options.model,
+                toolIds: options.tool,
+                toolsetId: options.toolset,
+                timeoutMs: options.timeoutMs,
+            };
+        await requestOperationAndPrint(factory, 'runtimes.invocations.create', {
+            pathParams: { runtimeId },
+            body: body,
+            idempotencyKey: options.idempotencyKey,
+            output: outputFlags(options),
+        });
+    });
+}
+function createRuntimeInvocationWaitCommand(factory) {
+    return createOperationJsonBodyCommand(factory, {
+        operationId: 'runtimes.invocations.wait',
+        name: 'wait',
+        description: 'Wait for an invocation',
+        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 (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(new Command('push')
-        .description('Upload and stage a local file into a runtime')
-        .argument('<runtime>')
-        .argument('<local-path>')
-        .option('--storage-path <path>', 'Advanced: durable BCTRL storage path')
+    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));
+    command.addCommand(createRuntimeFileStageCommand(factory));
+    command.addCommand(createRuntimeFileCollectCommand(factory));
+    return command;
+}
+function createRuntimeFileUploadCommand(factory) {
+    return addOutputFlags(new Command('upload')
+        .description('Upload a local file into a runtime workspace')
+        .argument('<runtimeId>')
+        .argument('<localPath>')
+        .option('--destination-path <path>', 'Durable BCTRL storage destination')
+        .option('--runtime-path <path>', 'Runtime workspace destination')
         .option('--name <name>', 'Display name')
-        .option('--metadata-file <path>', 'Metadata JSON file')).action(async (runtime, localPath, options) => {
-        const client = await factory.apiClient();
+        .option('--metadata-file <path>', 'Metadata JSON file')).action(async (runtimeId, localPath, options) => {
         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(runtime)}/files/upload`, {
+        const result = await uploadOperationFile(factory, 'runtimes.files.upload', {
+            pathParams: { runtimeId },
             file: file.blob,
             fileName: options.name ?? file.fileName,
             fields: {
-                ...(options.storagePath ? { storagePath: options.storagePath } : {}),
+                ...(options.destinationPath ? { destinationPath: options.destinationPath } : {}),
+                ...(options.runtimePath ? { runtimePath: options.runtimePath } : {}),
                 ...(options.name ? { name: options.name } : {}),
                 ...(metadata ? { metadata } : {}),
             },
         });
         await outputData(factory.io, result, options);
-    }));
-    command.addCommand(addOutputFlags(new Command('pull')
-        .description('Collect a runtime file and download it locally')
-        .argument('<runtime>')
-        .argument('<runtime-path>')
-        .requiredOption('--to <path>', 'Output path, or - for stdout')
-        .option('--name <name>', 'Durable file name')
-        .option('--storage-path <path>', 'Advanced: durable BCTRL storage path')).action(async (runtime, runtimePath, options) => {
-        const client = await factory.apiClient();
-        const collected = await client.post(`/runtimes/${encodeURIComponent(runtime)}/files/collect`, {
-            body: {
-                path: runtimePath,
-                name: options.name,
-                storagePath: options.storagePath,
-            },
-        });
-        if (!collected.id) {
-            throw new CliError('Expected runtime file collect response to include id');
-        }
-        const data = await client.download(`/files/${encodeURIComponent(collected.id)}/content`);
-        await writeBinary(options.to, data);
-    }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    });
+}
+function createRuntimeFileStageCommand(factory) {
+    return createOperationJsonBodyCommand(factory, {
+        operationId: 'runtimes.files.stage',
         name: 'stage',
         description: 'Stage a durable file into a runtime',
-        method: 'post',
-        path: '/runtimes/{runtime}/files/stage',
-        argNames: ['runtime'],
+        argNames: ['runtimeId'],
         configure: (cmd) => cmd
             .option('--file <id>', 'Durable file id')
-            .option('--storage-path <path>', 'Advanced: durable BCTRL storage path')
-            .option('--name <name>', 'Runtime-local name')
+            .option('--runtime-path <path>', 'Runtime workspace destination')
+            .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, storagePath: options.storagePath, name: options.name };
+            if (typeof options.input === 'string') {
+                return (await readJsonFile(options.input));
+            }
+            return {
+                fileId: options.file,
+                runtimePath: options.runtimePath,
+                name: options.name,
+            };
         },
-    }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    });
+}
+function createRuntimeFileCollectCommand(factory) {
+    return createOperationJsonBodyCommand(factory, {
+        operationId: 'runtimes.files.collect',
         name: 'collect',
         description: 'Collect a runtime-local file into durable storage',
-        method: 'post',
-        path: '/runtimes/{runtime}/files/collect',
-        argNames: ['runtime'],
+        argNames: ['runtimeId'],
         configure: (cmd) => cmd
-            .requiredOption('--path <path>', 'Runtime-local path')
+            .requiredOption('--runtime-path <path>', 'Runtime workspace source')
             .option('--name <name>', 'Durable file name')
-            .option('--storage-path <path>', 'Advanced: durable BCTRL storage path')
+            .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);
-            return { path: options.path, name: options.name, storagePath: options.storagePath };
+            if (typeof options.input === 'string') {
+                return (await readJsonFile(options.input));
+            }
+            return {
+                runtimePath: options.runtimePath,
+                name: options.name,
+                destinationPath: options.destinationPath,
+            };
         },
-    }));
-    return command;
+    });
 }

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,11 +6,17 @@ 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 {
         purpose: raw.summary,
-        flags: raw.flags?.map((flag) => ({ ...flag })),
+        flags: raw.cli?.flags?.map((flag) => ({ ...flag })),
         input: raw.input?.fields.map((field) => ({ ...field })),
         output: raw.output?.fields.map((field) => ({ ...field })),
         examples: raw.examples?.map(formatHelpItem).filter((value) => Boolean(value)),
@@ -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 {};