@camerontaylor/paseo-cli 0.8.0-fork.1

package/dist/commands/project/delete.js

@@ -0,0 +1,33 @@
+import { buildDaemonConnectionCommandError, connectToDaemon } from "../../utils/client.js";
+const projectDeleteSchema = {
+    idField: "projectId",
+    columns: [
+        { header: "PROJECT ID", field: "projectId", width: 20 },
+        {
+            header: "REMOVED WORKSPACES",
+            field: (result) => result.removedWorkspaceIds.length,
+            width: 18,
+        },
+    ],
+};
+export async function runDeleteCommand(projectId, options, _command) {
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        throw buildDaemonConnectionCommandError({ host: options.host, error });
+    });
+    try {
+        const result = await client.removeProject(projectId);
+        return {
+            type: "single",
+            data: { projectId, removedWorkspaceIds: result.removedWorkspaceIds },
+            schema: projectDeleteSchema,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "PROJECT_DELETE_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=delete.js.map

package/dist/commands/project/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createProjectCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/project/index.js

@@ -0,0 +1,28 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { runCreateCommand } from "./create.js";
+import { runDeleteCommand } from "./delete.js";
+import { runLsCommand } from "./ls.js";
+import { runRenameCommand } from "./rename.js";
+export function createProjectCommand() {
+    const project = new Command("project").description("Manage projects");
+    addJsonAndDaemonHostOptions(project
+        .command("create")
+        .description("Register a project directory")
+        .argument("[path]", "Project directory (default: current directory)")).action(withOutput(runCreateCommand));
+    addJsonAndDaemonHostOptions(project.command("ls").description("List projects")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(project
+        .command("rename")
+        .description("Set a project's user-visible name")
+        .argument("<project-id>", "Project id")
+        .argument("[name]", "New project name")
+        .option("--reset", "Clear the custom name and use the directory name")
+        .allowExcessArguments(false)).action(withOutput(runRenameCommand));
+    addJsonAndDaemonHostOptions(project
+        .command("delete")
+        .description("Delete a project and its workspaces")
+        .argument("<project-id>", "Project id")).action(withOutput(runDeleteCommand));
+    return project;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/project/ls.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult } from "../../output/index.js";
+import { type ProjectRow } from "./shared.js";
+export declare function runLsCommand(options: CommandOptions, _command: Command): Promise<ListResult<ProjectRow>>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/project/ls.js

@@ -0,0 +1,19 @@
+import { buildDaemonConnectionCommandError, connectToDaemon } from "../../utils/client.js";
+import { projectSchema, toProjectRow } from "./shared.js";
+export async function runLsCommand(options, _command) {
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        throw buildDaemonConnectionCommandError({ host: options.host, error });
+    });
+    try {
+        const payload = await client.listProjects();
+        return {
+            type: "list",
+            data: payload.projects.map(toProjectRow),
+            schema: projectSchema,
+        };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/commands/project/rename.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface ProjectRenameResult {
+    projectId: string;
+    name: string | null;
+}
+export declare function resolveProjectName(input: {
+    name?: string;
+    reset?: boolean;
+}): string | null;
+export declare function runRenameCommand(projectId: string, nameArg: string | undefined, options: CommandOptions & {
+    reset?: boolean;
+}, _command: Command): Promise<SingleResult<ProjectRenameResult>>;
+export {};
+//# sourceMappingURL=rename.d.ts.map

package/dist/commands/project/rename.js

@@ -0,0 +1,50 @@
+import { buildDaemonConnectionCommandError, connectToDaemon } from "../../utils/client.js";
+const projectRenameSchema = {
+    idField: "projectId",
+    columns: [
+        { header: "PROJECT ID", field: "projectId", width: 20 },
+        { header: "NAME", field: "name", width: 30 },
+    ],
+};
+export function resolveProjectName(input) {
+    if (input.reset) {
+        if (input.name !== undefined) {
+            throw {
+                code: "INVALID_OPTIONS",
+                message: "--reset cannot be combined with a name",
+            };
+        }
+        return null;
+    }
+    const name = input.name?.trim() ?? "";
+    if (name.length === 0) {
+        throw {
+            code: "MISSING_NAME",
+            message: "Project name cannot be empty",
+            details: "Usage: paseo project rename <project-id> <name> | --reset",
+        };
+    }
+    return name;
+}
+export async function runRenameCommand(projectId, nameArg, options, _command) {
+    const name = resolveProjectName({ name: nameArg, reset: options.reset });
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        throw buildDaemonConnectionCommandError({ host: options.host, error });
+    });
+    try {
+        const applied = await client.renameProject(projectId, name);
+        return {
+            type: "single",
+            data: { projectId, name: applied.customName },
+            schema: projectRenameSchema,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "PROJECT_RENAME_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=rename.js.map

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

@@ -0,0 +1,11 @@
+import type { WorkspaceProjectDescriptorPayload } from "@camerontaylor/paseo-protocol/messages";
+import type { OutputSchema } from "../../output/index.js";
+export interface ProjectRow {
+    projectId: string;
+    name: string;
+    kind: "git" | "non_git" | "directory";
+    path: string;
+}
+export declare const projectSchema: OutputSchema<ProjectRow>;
+export declare function toProjectRow(project: WorkspaceProjectDescriptorPayload): ProjectRow;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/project/shared.js

@@ -0,0 +1,18 @@
+export const projectSchema = {
+    idField: "projectId",
+    columns: [
+        { header: "PROJECT ID", field: "projectId", width: 20 },
+        { header: "NAME", field: "name", width: 24 },
+        { header: "KIND", field: "kind", width: 10 },
+        { header: "PATH", field: "path", width: 42 },
+    ],
+};
+export function toProjectRow(project) {
+    return {
+        projectId: project.projectId,
+        name: project.projectDisplayName,
+        kind: project.projectKind,
+        path: project.projectRootPath,
+    };
+}
+//# sourceMappingURL=shared.js.map

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

@@ -0,0 +1,30 @@
+import type { Command } from "commander";
+import type { ProviderOverride } from "@camerontaylor/paseo-protocol/provider-config";
+import type { CommandOptions, OutputSchema, SingleResult } from "../../output/index.js";
+export interface ProviderAddOptions extends CommandOptions {
+    extends?: string;
+    label?: string;
+    description?: string;
+    env?: string[];
+    model?: string[];
+    command?: string[];
+}
+export interface ProviderAddRow {
+    provider: string;
+    label: string;
+    extends: string;
+    models: string;
+    env: string;
+    command: string;
+}
+export declare const providerAddSchema: OutputSchema<ProviderAddRow>;
+/**
+ * Build the provider override for `provider add`. The daemon validates too; this
+ * catches the common mistakes before a round trip so the message names the flag.
+ */
+export declare function buildProviderOverride(id: string, options: ProviderAddOptions): {
+    id: string;
+    override: ProviderOverride;
+};
+export declare function runAddCommand(id: string, options: ProviderAddOptions, _command: Command): Promise<SingleResult<ProviderAddRow>>;
+//# sourceMappingURL=add.d.ts.map

package/dist/commands/provider/add.js

@@ -0,0 +1,123 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { PROVIDER_ID_PATTERN, VALID_EXTENDS_VALUES, isBuiltinProviderId } from "./shared.js";
+export const providerAddSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider", width: 16 },
+        { header: "LABEL", field: "label", width: 20 },
+        { header: "EXTENDS", field: "extends", width: 10 },
+        { header: "MODELS", field: "models", width: 30 },
+        { header: "ENV", field: "env", width: 24 },
+        { header: "COMMAND", field: "command", width: 30 },
+    ],
+};
+const ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function parseEnvEntries(entries) {
+    const env = {};
+    for (const entry of entries) {
+        const separator = entry.indexOf("=");
+        if (separator <= 0) {
+            throw new Error(`Invalid --env "${entry}": expected KEY=VALUE`);
+        }
+        const key = entry.slice(0, separator);
+        if (!ENV_KEY_PATTERN.test(key)) {
+            throw new Error(`Invalid --env key "${key}": must match ${ENV_KEY_PATTERN}`);
+        }
+        env[key] = entry.slice(separator + 1);
+    }
+    return env;
+}
+function parseModelEntries(entries) {
+    return entries.map((entry, index) => {
+        const separator = entry.indexOf("=");
+        const id = separator === -1 ? entry : entry.slice(0, separator);
+        const label = separator === -1 ? entry : entry.slice(separator + 1);
+        if (id.trim().length === 0) {
+            throw new Error(`Invalid --model "${entry}": expected id or id=label`);
+        }
+        if (label.trim().length === 0) {
+            throw new Error(`Invalid --model "${entry}": label must not be empty`);
+        }
+        return { id: id.trim(), label: label.trim(), ...(index === 0 ? { isDefault: true } : {}) };
+    });
+}
+/**
+ * Build the provider override for `provider add`. The daemon validates too; this
+ * catches the common mistakes before a round trip so the message names the flag.
+ */
+export function buildProviderOverride(id, options) {
+    if (!PROVIDER_ID_PATTERN.test(id)) {
+        throw new Error(`Invalid provider id "${id}": must start with a lowercase letter and contain only lowercase letters, digits, and hyphens`);
+    }
+    if (isBuiltinProviderId(id)) {
+        throw new Error(`"${id}" is a built-in provider. Pick a different id and use --extends ${id} to base a profile on it.`);
+    }
+    const extendsProvider = options.extends;
+    if (!extendsProvider) {
+        throw new Error(`--extends is required (one of: ${VALID_EXTENDS_VALUES.join(", ")})`);
+    }
+    if (!VALID_EXTENDS_VALUES.includes(extendsProvider)) {
+        throw new Error(`Invalid --extends "${extendsProvider}": expected one of ${VALID_EXTENDS_VALUES.join(", ")}`);
+    }
+    const commandArgv = options.command ?? [];
+    if (extendsProvider === "acp" && commandArgv.length === 0) {
+        throw new Error("--command is required when extending acp");
+    }
+    const env = parseEnvEntries(options.env ?? []);
+    const models = parseModelEntries(options.model ?? []);
+    const override = {
+        extends: extendsProvider,
+        label: options.label ?? id,
+        ...(options.description ? { description: options.description } : {}),
+        ...(commandArgv.length > 0 ? { command: commandArgv } : {}),
+        ...(Object.keys(env).length > 0 ? { env } : {}),
+        ...(models.length > 0 ? { models } : {}),
+    };
+    return { id, override };
+}
+function toRow(id, override) {
+    return {
+        provider: id,
+        label: override.label ?? id,
+        extends: override.extends ?? "-",
+        models: (override.models ?? []).map((model) => model.id).join(", ") || "-",
+        env: Object.keys(override.env ?? {}).join(", ") || "-",
+        command: (override.command ?? []).join(" ") || "-",
+    };
+}
+export async function runAddCommand(id, options, _command) {
+    let built;
+    try {
+        built = buildProviderOverride(id, options);
+    }
+    catch (error) {
+        throw {
+            code: "INVALID_PROVIDER_CONFIG",
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const host = getDaemonHost({ host: options.host });
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+        };
+    });
+    try {
+        const { config } = await client.getDaemonConfig();
+        if (built.id in (config.providers ?? {})) {
+            throw new Error(`Provider "${built.id}" already exists. Remove it with "paseo provider rm ${built.id}" first.`);
+        }
+        await client.patchDaemonConfig({ providers: { [built.id]: built.override } });
+        return { type: "single", data: toRow(built.id, built.override), schema: providerAddSchema };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "PROVIDER_ADD_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=add.js.map

package/dist/commands/provider/diagnostic.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "commander";
+import type { CommandOptions, OutputSchema, SingleResult } from "../../output/index.js";
+export interface ProviderDiagnosticResult {
+    provider: string;
+    diagnostic: string;
+}
+export declare const providerDiagnosticSchema: OutputSchema<ProviderDiagnosticResult>;
+export interface ProviderDiagnosticOptions extends CommandOptions {
+    host?: string;
+}
+export declare function runDiagnosticCommand(provider: string, options: ProviderDiagnosticOptions, _command: Command): Promise<SingleResult<ProviderDiagnosticResult>>;
+//# sourceMappingURL=diagnostic.d.ts.map

package/dist/commands/provider/diagnostic.js

@@ -0,0 +1,31 @@
+import { connectToDaemon } from "../../utils/client.js";
+export const providerDiagnosticSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider" },
+        { header: "DIAGNOSTIC", field: "diagnostic" },
+    ],
+    renderHuman(result) {
+        if (result.type === "single")
+            return result.data.diagnostic;
+        return result.data.map((entry) => entry.diagnostic).join("\n\n");
+    },
+};
+export async function runDiagnosticCommand(provider, options, _command) {
+    const client = await connectToDaemon({ host: options.host });
+    try {
+        const result = await client.getProviderDiagnostic(provider.trim().toLowerCase());
+        return {
+            type: "single",
+            data: {
+                provider: result.provider,
+                diagnostic: result.diagnostic,
+            },
+            schema: providerDiagnosticSchema,
+        };
+    }
+    finally {
+        await client.close();
+    }
+}
+//# sourceMappingURL=diagnostic.js.map

package/dist/commands/provider/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createProviderCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/provider/index.js

@@ -0,0 +1,38 @@
+import { Command } from "commander";
+import { runAddCommand } from "./add.js";
+import { runDiagnosticCommand } from "./diagnostic.js";
+import { runLsCommand } from "./ls.js";
+import { runModelsCommand } from "./models.js";
+import { runRmCommand } from "./rm.js";
+import { VALID_EXTENDS_VALUES } from "./shared.js";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions, collectMultiple } from "../../utils/command-options.js";
+export function createProviderCommand() {
+    const provider = new Command("provider").description("Manage agent providers");
+    addJsonAndDaemonHostOptions(provider.command("ls").description("List available providers and status")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(provider
+        .command("models")
+        .description("List models for a provider")
+        .argument("<provider>", "Provider name (claude, codex, opencode)")
+        .option("--thinking", "Include thinking option IDs for each model")).action(withOutput(runModelsCommand));
+    addJsonAndDaemonHostOptions(provider
+        .command("diagnostic")
+        .description("Show provider installation, environment, and availability diagnostics")
+        .argument("<provider>", "Provider name")).action(withOutput(runDiagnosticCommand));
+    addJsonAndDaemonHostOptions(provider
+        .command("add")
+        .description("Add a custom provider profile")
+        .argument("<id>", "New provider id (lowercase letters, digits, hyphens)")
+        .requiredOption("--extends <provider>", `Provider to inherit from (${VALID_EXTENDS_VALUES.join(", ")})`)
+        .option("--label <label>", "Display label (default: the provider id)")
+        .option("--description <text>", "Description shown next to the label")
+        .option("--env <KEY=VALUE>", "Environment variable, repeatable", collectMultiple, [])
+        .option("--model <id[=label]>", "Model offered by this profile, repeatable; the first is the default", collectMultiple, [])
+        .option("--command <arg>", "Launch argv entry, repeatable; required with --extends acp", collectMultiple, [])).action(withOutput(runAddCommand));
+    addJsonAndDaemonHostOptions(provider
+        .command("rm")
+        .description("Remove a custom provider profile")
+        .argument("<id>", "Custom provider id")).action(withOutput(runRmCommand));
+    return provider;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/provider/ls.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+import type { ProviderSnapshotEntry } from "@camerontaylor/paseo-protocol/agent-types";
+export interface ProviderListItem {
+    provider: ProviderSnapshotEntry["provider"];
+    label: string;
+    source: "builtin" | "custom";
+    status: string;
+    enabled: "Enabled" | "Disabled";
+    defaultMode: string;
+    modes: string;
+}
+/** Schema for provider ls output */
+export declare const providerLsSchema: OutputSchema<ProviderListItem>;
+export type ProviderLsResult = ListResult<ProviderListItem>;
+export interface ProviderLsOptions extends CommandOptions {
+    host?: string;
+}
+export declare function runLsCommand(options: ProviderLsOptions, _command: Command): Promise<ProviderLsResult>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/provider/ls.js

@@ -0,0 +1,76 @@
+import { AGENT_PROVIDER_DEFINITIONS } from "@camerontaylor/paseo-protocol/provider-manifest";
+import { tryConnectToDaemon } from "../../utils/client.js";
+/** Derive provider list from the manifest — single source of truth */
+const PROVIDERS = AGENT_PROVIDER_DEFINITIONS.map((def) => ({
+    provider: def.id,
+    label: def.label,
+    source: "builtin",
+    status: "available",
+    enabled: def.enabledByDefault === false ? "Disabled" : "Enabled",
+    defaultMode: def.defaultModeId ?? "-",
+    modes: def.modes.length > 0 ? def.modes.map((m) => m.label).join(", ") : "-",
+}));
+function getStaticProviders() {
+    return PROVIDERS;
+}
+/** Schema for provider ls output */
+export const providerLsSchema = {
+    idField: "provider",
+    columns: [
+        { header: "PROVIDER", field: "provider", width: 12 },
+        { header: "LABEL", field: "label", width: 16 },
+        { header: "SOURCE", field: "source", width: 8 },
+        {
+            header: "STATUS",
+            field: "status",
+            width: 12,
+            color: (value) => {
+                if (value === "available")
+                    return "green";
+                if (value === "unavailable")
+                    return "red";
+                return undefined;
+            },
+        },
+        { header: "ENABLED", field: "enabled", width: 10 },
+        { header: "DEFAULT MODE", field: "defaultMode", width: 14 },
+        { header: "MODES", field: "modes", width: 30 },
+    ],
+};
+export async function runLsCommand(options, _command) {
+    const client = await tryConnectToDaemon({ host: options.host });
+    if (!client) {
+        return {
+            type: "list",
+            data: getStaticProviders(),
+            schema: providerLsSchema,
+        };
+    }
+    try {
+        const snapshot = await client.getProvidersSnapshot();
+        return {
+            type: "list",
+            data: snapshot.entries.map((entry) => ({
+                provider: entry.provider,
+                label: entry.label ?? entry.provider,
+                source: entry.source ?? "builtin",
+                status: entry.status === "ready" ? "available" : entry.status,
+                enabled: !entry.enabled ? "Disabled" : "Enabled",
+                defaultMode: entry.defaultModeId ?? "default",
+                modes: (entry.modes ?? []).map((mode) => mode.label).join(", "),
+            })),
+            schema: providerLsSchema,
+        };
+    }
+    catch {
+        return {
+            type: "list",
+            data: getStaticProviders(),
+            schema: providerLsSchema,
+        };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/commands/provider/models.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+/** Model list item for display */
+export interface ModelListItem {
+    model: string;
+    id: string;
+    description: string;
+    thinkingOptionIds: string[];
+    defaultThinkingOptionId: string | null;
+    thinkingOptions: string;
+}
+/** Schema for provider models output */
+export declare const providerModelsSchema: OutputSchema<ModelListItem>;
+export type ProviderModelsResult = ListResult<ModelListItem>;
+export interface ProviderModelsOptions extends CommandOptions {
+    host?: string;
+    thinking?: boolean;
+}
+export declare function runModelsCommand(provider: string, options: ProviderModelsOptions, _command: Command): Promise<ProviderModelsResult>;
+//# sourceMappingURL=models.d.ts.map

package/dist/commands/provider/models.js

@@ -0,0 +1,53 @@
+import { connectToDaemon } from "../../utils/client.js";
+/** Schema for provider models output */
+export const providerModelsSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 30 },
+        { header: "MODEL", field: "model", width: 30 },
+        { header: "DESCRIPTION", field: "description", width: 40 },
+    ],
+};
+const providerModelsWithThinkingSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 30 },
+        { header: "MODEL", field: "model", width: 30 },
+        { header: "THINKING IDS", field: "thinkingOptions", width: 40 },
+        {
+            header: "DEFAULT THINKING",
+            field: (item) => item.defaultThinkingOptionId ?? "auto",
+            width: 18,
+        },
+    ],
+};
+export async function runModelsCommand(provider, options, _command) {
+    const normalizedProvider = provider.toLowerCase();
+    const client = await connectToDaemon({ host: options.host });
+    try {
+        const result = await client.listProviderModels(normalizedProvider);
+        if (result.error) {
+            throw {
+                code: "PROVIDER_ERROR",
+                message: `Failed to fetch models for ${provider}: ${result.error}`,
+            };
+        }
+        const models = (result.models ?? []).map((m) => ({
+            model: m.label,
+            id: m.id,
+            description: m.description ?? "",
+            thinkingOptionIds: (m.thinkingOptions ?? []).map((option) => option.id),
+            defaultThinkingOptionId: m.defaultThinkingOptionId ?? null,
+            thinkingOptions: (m.thinkingOptions ?? []).map((option) => option.id).join(", ") || "none",
+        }));
+        return {
+            type: "list",
+            data: models,
+            schema: options.thinking ? providerModelsWithThinkingSchema : providerModelsSchema,
+        };
+    }
+    finally {
+        await client.close();
+    }
+}
+//# sourceMappingURL=models.js.map

package/dist/commands/provider/rm.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+import type { CommandOptions, OutputSchema, SingleResult } from "../../output/index.js";
+export type ProviderRmOptions = CommandOptions;
+export interface ProviderRmRow {
+    provider: string;
+    removed: string;
+}
+export declare const providerRmSchema: OutputSchema<ProviderRmRow>;
+export declare function runRmCommand(id: string, options: ProviderRmOptions, _command: Command): Promise<SingleResult<ProviderRmRow>>;
+//# sourceMappingURL=rm.d.ts.map