@camunda8/cli 2.7.0-alpha.1 → 2.7.0-alpha.10

package/dist/command-registry.d.ts

@@ -5,15 +5,48 @@
  * Consumers (help, completion, validation, dispatch) derive their
  * data from this registry instead of maintaining separate copies.
  */
+import { AuthorizationKey, IncidentKey, JobKey, ProcessDefinitionId, ProcessDefinitionKey, ProcessInstanceKey, TenantId, Username, UserTaskKey } from "@camunda8/orchestration-cluster-api";
 export interface FlagDef {
+    /** Value type: "string" expects an argument, "boolean" is a presence flag. */
     type: "string" | "boolean";
+    /** One-line description shown in command-level help output. */
     description: string;
+    /** Single-character alias (e.g. "k" → -k). */
     short?: string;
+    /** When true, the flag must be supplied or the command exits with an error. */
     required?: boolean;
     /** SDK enum object for automatic validation (keys are valid values). */
     enum?: Record<string, string>;
     /** When true, flag value is comma-separated and each item is validated against enum. */
     csv?: boolean;
+    /**
+     * Transform and validate raw CLI input into a typed value.
+     * Called at the validation boundary before dispatch.
+     * Should throw on invalid input (error message is surfaced to the user).
+     * Each concrete validator returns its branded type (e.g. ProcessDefinitionKey),
+     * erased to unknown here since FlagDef holds heterogeneous validators.
+     */
+    validate?: (value: string) => any;
+    /** When true, this flag appears in the top-level `c8ctl help` Flags section. */
+    showInTopLevelHelp?: boolean;
+    /** Context hint shown in the top-level help (e.g. "use with 'get pd'"). */
+    helpHint?: string;
+    /** Rich description for agent-facing help (AI/programmatic consumers). Shown in Agent Flags section. */
+    agentDescription?: string;
+    /** Scope hint for agent-facing help (e.g. "all commands", "all list/search/get commands"). */
+    agentAppliesTo?: string;
+}
+/**
+ * Schema for a single positional argument.
+ *
+ * - `name`: used as the key in the typed args record and in error messages
+ * - `required`: when true, missing value exits with an error
+ * - `validate`: optional branded-type constructor (e.g. ProcessDefinitionKey.assumeExists)
+ */
+export interface PositionalDef {
+    name: string;
+    required?: boolean;
+    validate?: (value: string) => any;
 }
 export interface CommandDef {
     description: string;
@@ -22,10 +55,42 @@ export interface CommandDef {
     requiresResource: boolean;
     /** Valid resource names (canonical short forms used in help). */
     resources: string[];
-    /** Flags specific to this verb (beyond global flags). */
+    /** Flags specific to this verb (beyond global flags). Superset of all resource-specific flags. */
     flags: Record<string, FlagDef>;
+    /** Per-resource flag scoping. Keys are canonical resource names. */
+    resourceFlags?: Record<string, Record<string, FlagDef>>;
+    /** Per-resource positional argument schemas. Keys are canonical resource names. */
+    resourcePositionals?: Record<string, readonly PositionalDef[]>;
     /** Verb aliases that dispatch to this command (e.g. "rm" → remove, "w" → watch). */
     aliases?: string[];
+    /**
+     * Override the resource column in `c8ctl help` output.
+     * Auto-derived from resources/positionals when omitted.
+     */
+    helpResource?: string;
+    /**
+     * Override the description shown in `c8ctl help` output.
+     * Falls back to `description` when omitted.
+     */
+    helpDescription?: string;
+    /**
+     * When true, `c8ctl help <verb>` is listed in the footer of main help.
+     * Derived: true for any verb with a showCommandHelp handler.
+     */
+    hasDetailedHelp?: boolean;
+    /**
+     * Short label for the `c8ctl help <verb>` footer entry.
+     * Defaults to "Show <verb> command with all flags".
+     */
+    helpFooterLabel?: string;
+    /**
+     * Examples shown in the top-level `c8ctl help` Examples section.
+     * Each entry: { command, description }. Rendered in declaration order.
+     */
+    helpExamples?: readonly {
+        command: string;
+        description: string;
+    }[];
 }
 /**
  * Maps short/plural resource names to their canonical singular form.
@@ -35,18 +100,1952 @@ export declare const RESOURCE_ALIASES: Record<string, string>;
 /**
  * Flags accepted by every command (infrastructure/agent flags).
  */
-export declare const GLOBAL_FLAGS: Record<string, FlagDef>;
+export declare const GLOBAL_FLAGS: {
+    readonly help: {
+        readonly type: "boolean";
+        readonly description: "Show help";
+        readonly short: "h";
+    };
+    readonly version: {
+        readonly type: "string";
+        readonly description: "Show CLI version, or filter by process definition version on supported commands";
+        readonly short: "v";
+    };
+    readonly profile: {
+        readonly type: "string";
+        readonly description: "Use a specific profile";
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Preview the API request without executing";
+        readonly agentDescription: "Preview the API request that would be sent, without executing it.\nEmits JSON: { dryRun, command, method, url, body }\nAlways exits 0.";
+        readonly agentAppliesTo: "all commands";
+    };
+    readonly verbose: {
+        readonly type: "boolean";
+        readonly description: "Show verbose output";
+    };
+    readonly fields: {
+        readonly type: "string";
+        readonly description: "Comma-separated list of fields to display";
+        readonly agentDescription: "Comma-separated list of output fields to include.\nReduces context window size when parsing output.\nExample: c8ctl list pi --fields Key,State,processDefinitionId\nCase-insensitive.";
+        readonly agentAppliesTo: "all list/search/get commands";
+    };
+};
 /**
  * Flags shared across all search/list commands.
  */
-export declare const SEARCH_FLAGS: Record<string, FlagDef>;
-export declare const COMMAND_REGISTRY: Record<string, CommandDef>;
-/**
- * Maps each searchable resource (canonical name) to the set of flag names
- * that are valid for that resource's search command. Used for unknown-flag
- * detection in search commands.
- */
-export declare const SEARCH_RESOURCE_FLAGS: Record<string, Set<string>>;
+export declare const SEARCH_FLAGS: {
+    readonly sortBy: {
+        readonly type: "string";
+        readonly description: "Sort results by field";
+    };
+    readonly asc: {
+        readonly type: "boolean";
+        readonly description: "Sort ascending";
+    };
+    readonly desc: {
+        readonly type: "boolean";
+        readonly description: "Sort descending";
+    };
+    readonly limit: {
+        readonly type: "string";
+        readonly description: "Maximum number of results";
+    };
+    readonly between: {
+        readonly type: "string";
+        readonly description: "Date range filter (e.g. 7d, 30d, 2024-01-01..2024-12-31)";
+    };
+    readonly dateField: {
+        readonly type: "string";
+        readonly description: "Date field for --between filter";
+    };
+};
+export declare const GET_PD_FLAGS: {
+    readonly xml: {
+        readonly type: "boolean";
+        readonly description: "Get BPMN XML (process definitions)";
+        readonly showInTopLevelHelp: true;
+        readonly helpHint: "use with 'get pd'";
+    };
+};
+export declare const GET_PD_POSITIONALS: readonly [{
+    readonly name: "key";
+    readonly required: true;
+    readonly validate: typeof ProcessDefinitionKey.assumeExists;
+}];
+export declare const COMMAND_REGISTRY: {
+    list: {
+        description: string;
+        helpDescription: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: false;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {
+            mappingRuleId: {
+                readonly type: "string";
+                readonly description: "Filter by mapping rule ID";
+            };
+            name: {
+                readonly type: "string";
+                readonly description: "Filter by name";
+            };
+            claimName: {
+                readonly type: "string";
+                readonly description: "Filter by claim name";
+            };
+            claimValue: {
+                readonly type: "string";
+                readonly description: "Filter by claim value";
+            };
+            ownerId: {
+                readonly type: "string";
+                readonly description: "Filter by owner ID";
+            };
+            ownerType: {
+                readonly type: "string";
+                readonly description: "Filter by owner type";
+            };
+            resourceType: {
+                readonly type: "string";
+                readonly description: "Filter by resource type";
+            };
+            resourceId: {
+                readonly type: "string";
+                readonly description: "Filter by resource ID";
+            };
+            tenantId: {
+                readonly type: "string";
+                readonly description: "Filter by tenant ID";
+                readonly validate: typeof TenantId.assumeExists;
+            };
+            groupId: {
+                readonly type: "string";
+                readonly description: "Filter by group ID";
+            };
+            roleId: {
+                readonly type: "string";
+                readonly description: "Filter by role ID";
+            };
+            username: {
+                readonly type: "string";
+                readonly description: "Filter by username";
+                readonly validate: typeof Username.assumeExists;
+            };
+            email: {
+                readonly type: "string";
+                readonly description: "Filter by email";
+            };
+            state: {
+                readonly type: "string";
+                readonly description: "Filter by state";
+            };
+            type: {
+                readonly type: "string";
+                readonly description: "Filter by job type";
+            };
+            processInstanceKey: {
+                readonly type: "string";
+                readonly description: "Filter by process instance key";
+                readonly validate: typeof ProcessInstanceKey.assumeExists;
+            };
+            processDefinitionKey: {
+                readonly type: "string";
+                readonly description: "Filter by process definition key";
+                readonly validate: typeof ProcessDefinitionKey.assumeExists;
+            };
+            itype: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by job type";
+            };
+            bpmnProcessId: {
+                readonly type: "string";
+                readonly description: "Filter by BPMN process ID";
+            };
+            id: {
+                readonly type: "string";
+                readonly description: "Filter by BPMN process ID (alias)";
+            };
+            processDefinitionId: {
+                readonly type: "string";
+                readonly description: "Filter by process definition ID";
+                readonly validate: typeof ProcessDefinitionId.assumeExists;
+            };
+            errorType: {
+                readonly type: "string";
+                readonly description: "Filter by error type";
+            };
+            errorMessage: {
+                readonly type: "string";
+                readonly description: "Filter by error message";
+            };
+            ierrorMessage: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by error message";
+            };
+            iid: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by BPMN process ID";
+            };
+            assignee: {
+                readonly type: "string";
+                readonly description: "Filter by assignee";
+            };
+            elementId: {
+                readonly type: "string";
+                readonly description: "Filter by element ID";
+            };
+            iassignee: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by assignee";
+            };
+            key: {
+                readonly type: "string";
+                readonly description: "Filter by key";
+            };
+            iname: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by name";
+            };
+            parentProcessInstanceKey: {
+                readonly type: "string";
+                readonly description: "Filter by parent process instance key";
+                readonly validate: typeof ProcessInstanceKey.assumeExists;
+            };
+            sortBy: {
+                readonly type: "string";
+                readonly description: "Sort results by field";
+            };
+            asc: {
+                readonly type: "boolean";
+                readonly description: "Sort ascending";
+            };
+            desc: {
+                readonly type: "boolean";
+                readonly description: "Sort descending";
+            };
+            limit: {
+                readonly type: "string";
+                readonly description: "Maximum number of results";
+            };
+            between: {
+                readonly type: "string";
+                readonly description: "Date range filter (e.g. 7d, 30d, 2024-01-01..2024-12-31)";
+            };
+            dateField: {
+                readonly type: "string";
+                readonly description: "Date field for --between filter";
+            };
+            all: {
+                type: "boolean";
+                description: string;
+            };
+        };
+        resourceFlags: {
+            "process-definition": {
+                readonly bpmnProcessId: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID (alias)";
+                };
+                readonly processDefinitionId: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition ID";
+                    readonly validate: typeof ProcessDefinitionId.assumeExists;
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+                readonly key: {
+                    readonly type: "string";
+                    readonly description: "Filter by key";
+                };
+                readonly iid: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by BPMN process ID";
+                };
+                readonly iname: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by name";
+                };
+            };
+            "process-instance": {
+                readonly bpmnProcessId: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID (alias)";
+                };
+                readonly processDefinitionId: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition ID";
+                    readonly validate: typeof ProcessDefinitionId.assumeExists;
+                };
+                readonly processDefinitionKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition key";
+                    readonly validate: typeof ProcessDefinitionKey.assumeExists;
+                };
+                readonly state: {
+                    readonly type: "string";
+                    readonly description: "Filter by state (ACTIVE, COMPLETED, etc)";
+                };
+                readonly key: {
+                    readonly type: "string";
+                    readonly description: "Filter by key";
+                };
+                readonly parentProcessInstanceKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by parent process instance key";
+                    readonly validate: typeof ProcessInstanceKey.assumeExists;
+                };
+                readonly iid: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by BPMN process ID";
+                };
+            };
+            "user-task": {
+                readonly state: {
+                    readonly type: "string";
+                    readonly description: "Filter by state";
+                };
+                readonly assignee: {
+                    readonly type: "string";
+                    readonly description: "Filter by assignee";
+                };
+                readonly processInstanceKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process instance key";
+                    readonly validate: typeof ProcessInstanceKey.assumeExists;
+                };
+                readonly processDefinitionKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition key";
+                    readonly validate: typeof ProcessDefinitionKey.assumeExists;
+                };
+                readonly elementId: {
+                    readonly type: "string";
+                    readonly description: "Filter by element ID";
+                };
+                readonly iassignee: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by assignee";
+                };
+            };
+            incident: {
+                readonly state: {
+                    readonly type: "string";
+                    readonly description: "Filter by state";
+                };
+                readonly processInstanceKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process instance key";
+                    readonly validate: typeof ProcessInstanceKey.assumeExists;
+                };
+                readonly processDefinitionKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition key";
+                    readonly validate: typeof ProcessDefinitionKey.assumeExists;
+                };
+                readonly bpmnProcessId: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID (alias)";
+                };
+                readonly processDefinitionId: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition ID";
+                    readonly validate: typeof ProcessDefinitionId.assumeExists;
+                };
+                readonly errorType: {
+                    readonly type: "string";
+                    readonly description: "Filter by error type";
+                };
+                readonly errorMessage: {
+                    readonly type: "string";
+                    readonly description: "Filter by error message";
+                };
+                readonly ierrorMessage: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by error message";
+                };
+                readonly iid: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by BPMN process ID";
+                };
+            };
+            jobs: {
+                readonly state: {
+                    readonly type: "string";
+                    readonly description: "Filter by state";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly description: "Filter by job type";
+                };
+                readonly processInstanceKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process instance key";
+                    readonly validate: typeof ProcessInstanceKey.assumeExists;
+                };
+                readonly processDefinitionKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition key";
+                    readonly validate: typeof ProcessDefinitionKey.assumeExists;
+                };
+                readonly itype: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by job type";
+                };
+            };
+            user: {
+                readonly username: {
+                    readonly type: "string";
+                    readonly description: "Filter by username";
+                    readonly validate: typeof Username.assumeExists;
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+                readonly email: {
+                    readonly type: "string";
+                    readonly description: "Filter by email";
+                };
+            };
+            role: {
+                readonly roleId: {
+                    readonly type: "string";
+                    readonly description: "Filter by role ID";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+            };
+            group: {
+                readonly groupId: {
+                    readonly type: "string";
+                    readonly description: "Filter by group ID";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+            };
+            tenant: {
+                readonly tenantId: {
+                    readonly type: "string";
+                    readonly description: "Filter by tenant ID";
+                    readonly validate: typeof TenantId.assumeExists;
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+            };
+            authorization: {
+                readonly ownerId: {
+                    readonly type: "string";
+                    readonly description: "Filter by owner ID";
+                };
+                readonly ownerType: {
+                    readonly type: "string";
+                    readonly description: "Filter by owner type";
+                };
+                readonly resourceType: {
+                    readonly type: "string";
+                    readonly description: "Filter by resource type";
+                };
+                readonly resourceId: {
+                    readonly type: "string";
+                    readonly description: "Filter by resource ID";
+                };
+            };
+            "mapping-rule": {
+                readonly mappingRuleId: {
+                    readonly type: "string";
+                    readonly description: "Filter by mapping rule ID";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+                readonly claimName: {
+                    readonly type: "string";
+                    readonly description: "Filter by claim name";
+                };
+                readonly claimValue: {
+                    readonly type: "string";
+                    readonly description: "Filter by claim value";
+                };
+            };
+        };
+    };
+    search: {
+        description: string;
+        helpDescription: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: false;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {
+            mappingRuleId: {
+                readonly type: "string";
+                readonly description: "Filter by mapping rule ID";
+            };
+            name: {
+                readonly type: "string";
+                readonly description: "Filter by name";
+            };
+            claimName: {
+                readonly type: "string";
+                readonly description: "Filter by claim name";
+            };
+            claimValue: {
+                readonly type: "string";
+                readonly description: "Filter by claim value";
+            };
+            ownerId: {
+                readonly type: "string";
+                readonly description: "Filter by owner ID";
+            };
+            ownerType: {
+                readonly type: "string";
+                readonly description: "Filter by owner type";
+            };
+            resourceType: {
+                readonly type: "string";
+                readonly description: "Filter by resource type";
+            };
+            resourceId: {
+                readonly type: "string";
+                readonly description: "Filter by resource ID";
+            };
+            tenantId: {
+                readonly type: "string";
+                readonly description: "Filter by tenant ID";
+                readonly validate: typeof TenantId.assumeExists;
+            };
+            groupId: {
+                readonly type: "string";
+                readonly description: "Filter by group ID";
+            };
+            roleId: {
+                readonly type: "string";
+                readonly description: "Filter by role ID";
+            };
+            username: {
+                readonly type: "string";
+                readonly description: "Filter by username";
+                readonly validate: typeof Username.assumeExists;
+            };
+            email: {
+                readonly type: "string";
+                readonly description: "Filter by email";
+            };
+            value: {
+                readonly type: "string";
+                readonly description: "Filter by value";
+            };
+            processInstanceKey: {
+                readonly type: "string";
+                readonly description: "Filter by process instance key";
+                readonly validate: typeof ProcessInstanceKey.assumeExists;
+            };
+            scopeKey: {
+                readonly type: "string";
+                readonly description: "Filter by scope key";
+            };
+            fullValue: {
+                readonly type: "boolean";
+                readonly description: "Return full variable values (not truncated)";
+            };
+            iname: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by name";
+            };
+            ivalue: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by value";
+            };
+            state: {
+                readonly type: "string";
+                readonly description: "Filter by state";
+            };
+            type: {
+                readonly type: "string";
+                readonly description: "Filter by job type";
+            };
+            processDefinitionKey: {
+                readonly type: "string";
+                readonly description: "Filter by process definition key";
+                readonly validate: typeof ProcessDefinitionKey.assumeExists;
+            };
+            itype: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by job type";
+            };
+            bpmnProcessId: {
+                readonly type: "string";
+                readonly description: "Filter by BPMN process ID";
+            };
+            id: {
+                readonly type: "string";
+                readonly description: "Filter by BPMN process ID (alias)";
+            };
+            processDefinitionId: {
+                readonly type: "string";
+                readonly description: "Filter by process definition ID";
+                readonly validate: typeof ProcessDefinitionId.assumeExists;
+            };
+            errorType: {
+                readonly type: "string";
+                readonly description: "Filter by error type";
+            };
+            errorMessage: {
+                readonly type: "string";
+                readonly description: "Filter by error message";
+            };
+            ierrorMessage: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by error message";
+            };
+            iid: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by BPMN process ID";
+            };
+            assignee: {
+                readonly type: "string";
+                readonly description: "Filter by assignee";
+            };
+            elementId: {
+                readonly type: "string";
+                readonly description: "Filter by element ID";
+            };
+            iassignee: {
+                readonly type: "string";
+                readonly description: "Case-insensitive filter by assignee";
+            };
+            key: {
+                readonly type: "string";
+                readonly description: "Filter by key";
+            };
+            parentProcessInstanceKey: {
+                readonly type: "string";
+                readonly description: "Filter by parent process instance key";
+                readonly validate: typeof ProcessInstanceKey.assumeExists;
+            };
+            sortBy: {
+                readonly type: "string";
+                readonly description: "Sort results by field";
+            };
+            asc: {
+                readonly type: "boolean";
+                readonly description: "Sort ascending";
+            };
+            desc: {
+                readonly type: "boolean";
+                readonly description: "Sort descending";
+            };
+            limit: {
+                readonly type: "string";
+                readonly description: "Maximum number of results";
+            };
+            between: {
+                readonly type: "string";
+                readonly description: "Date range filter (e.g. 7d, 30d, 2024-01-01..2024-12-31)";
+            };
+            dateField: {
+                readonly type: "string";
+                readonly description: "Date field for --between filter";
+            };
+        };
+        resourceFlags: {
+            "process-definition": {
+                readonly bpmnProcessId: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID (alias)";
+                };
+                readonly processDefinitionId: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition ID";
+                    readonly validate: typeof ProcessDefinitionId.assumeExists;
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+                readonly key: {
+                    readonly type: "string";
+                    readonly description: "Filter by key";
+                };
+                readonly iid: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by BPMN process ID";
+                };
+                readonly iname: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by name";
+                };
+            };
+            "process-instance": {
+                readonly bpmnProcessId: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID (alias)";
+                };
+                readonly processDefinitionId: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition ID";
+                    readonly validate: typeof ProcessDefinitionId.assumeExists;
+                };
+                readonly processDefinitionKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition key";
+                    readonly validate: typeof ProcessDefinitionKey.assumeExists;
+                };
+                readonly state: {
+                    readonly type: "string";
+                    readonly description: "Filter by state (ACTIVE, COMPLETED, etc)";
+                };
+                readonly key: {
+                    readonly type: "string";
+                    readonly description: "Filter by key";
+                };
+                readonly parentProcessInstanceKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by parent process instance key";
+                    readonly validate: typeof ProcessInstanceKey.assumeExists;
+                };
+                readonly iid: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by BPMN process ID";
+                };
+            };
+            "user-task": {
+                readonly state: {
+                    readonly type: "string";
+                    readonly description: "Filter by state";
+                };
+                readonly assignee: {
+                    readonly type: "string";
+                    readonly description: "Filter by assignee";
+                };
+                readonly processInstanceKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process instance key";
+                    readonly validate: typeof ProcessInstanceKey.assumeExists;
+                };
+                readonly processDefinitionKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition key";
+                    readonly validate: typeof ProcessDefinitionKey.assumeExists;
+                };
+                readonly elementId: {
+                    readonly type: "string";
+                    readonly description: "Filter by element ID";
+                };
+                readonly iassignee: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by assignee";
+                };
+            };
+            incident: {
+                readonly state: {
+                    readonly type: "string";
+                    readonly description: "Filter by state";
+                };
+                readonly processInstanceKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process instance key";
+                    readonly validate: typeof ProcessInstanceKey.assumeExists;
+                };
+                readonly processDefinitionKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition key";
+                    readonly validate: typeof ProcessDefinitionKey.assumeExists;
+                };
+                readonly bpmnProcessId: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID";
+                };
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "Filter by BPMN process ID (alias)";
+                };
+                readonly processDefinitionId: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition ID";
+                    readonly validate: typeof ProcessDefinitionId.assumeExists;
+                };
+                readonly errorType: {
+                    readonly type: "string";
+                    readonly description: "Filter by error type";
+                };
+                readonly errorMessage: {
+                    readonly type: "string";
+                    readonly description: "Filter by error message";
+                };
+                readonly ierrorMessage: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by error message";
+                };
+                readonly iid: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by BPMN process ID";
+                };
+            };
+            jobs: {
+                readonly state: {
+                    readonly type: "string";
+                    readonly description: "Filter by state";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly description: "Filter by job type";
+                };
+                readonly processInstanceKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process instance key";
+                    readonly validate: typeof ProcessInstanceKey.assumeExists;
+                };
+                readonly processDefinitionKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process definition key";
+                    readonly validate: typeof ProcessDefinitionKey.assumeExists;
+                };
+                readonly itype: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by job type";
+                };
+            };
+            variable: {
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by variable name";
+                };
+                readonly value: {
+                    readonly type: "string";
+                    readonly description: "Filter by value";
+                };
+                readonly processInstanceKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by process instance key";
+                    readonly validate: typeof ProcessInstanceKey.assumeExists;
+                };
+                readonly scopeKey: {
+                    readonly type: "string";
+                    readonly description: "Filter by scope key";
+                };
+                readonly fullValue: {
+                    readonly type: "boolean";
+                    readonly description: "Return full variable values (not truncated)";
+                };
+                readonly iname: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by name";
+                };
+                readonly ivalue: {
+                    readonly type: "string";
+                    readonly description: "Case-insensitive filter by value";
+                };
+            };
+            user: {
+                readonly username: {
+                    readonly type: "string";
+                    readonly description: "Filter by username";
+                    readonly validate: typeof Username.assumeExists;
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+                readonly email: {
+                    readonly type: "string";
+                    readonly description: "Filter by email";
+                };
+            };
+            role: {
+                readonly roleId: {
+                    readonly type: "string";
+                    readonly description: "Filter by role ID";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+            };
+            group: {
+                readonly groupId: {
+                    readonly type: "string";
+                    readonly description: "Filter by group ID";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+            };
+            tenant: {
+                readonly tenantId: {
+                    readonly type: "string";
+                    readonly description: "Filter by tenant ID";
+                    readonly validate: typeof TenantId.assumeExists;
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+            };
+            authorization: {
+                readonly ownerId: {
+                    readonly type: "string";
+                    readonly description: "Filter by owner ID";
+                };
+                readonly ownerType: {
+                    readonly type: "string";
+                    readonly description: "Filter by owner type";
+                };
+                readonly resourceType: {
+                    readonly type: "string";
+                    readonly description: "Filter by resource type";
+                };
+                readonly resourceId: {
+                    readonly type: "string";
+                    readonly description: "Filter by resource ID";
+                };
+            };
+            "mapping-rule": {
+                readonly mappingRuleId: {
+                    readonly type: "string";
+                    readonly description: "Filter by mapping rule ID";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Filter by name";
+                };
+                readonly claimName: {
+                    readonly type: "string";
+                    readonly description: "Filter by claim name";
+                };
+                readonly claimValue: {
+                    readonly type: "string";
+                    readonly description: "Filter by claim value";
+                };
+            };
+        };
+    };
+    get: {
+        description: string;
+        helpDescription: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: false;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {
+            variables: {
+                readonly type: "boolean";
+                readonly description: "Include variables in output";
+                readonly showInTopLevelHelp: true;
+                readonly helpHint: "use with 'get pi'";
+            };
+            userTask: {
+                readonly type: "boolean";
+                readonly description: "Get form for user task";
+                readonly showInTopLevelHelp: true;
+                readonly helpHint: "use with 'get form'";
+            };
+            ut: {
+                readonly type: "boolean";
+                readonly description: "Alias for --userTask";
+            };
+            processDefinition: {
+                readonly type: "boolean";
+                readonly description: "Get form for process definition";
+                readonly showInTopLevelHelp: true;
+                readonly helpHint: "use with 'get form'";
+            };
+            pd: {
+                readonly type: "boolean";
+                readonly description: "Alias for --processDefinition";
+            };
+            xml: {
+                readonly type: "boolean";
+                readonly description: "Get BPMN XML (process definitions)";
+                readonly showInTopLevelHelp: true;
+                readonly helpHint: "use with 'get pd'";
+            };
+        };
+        resourceFlags: {
+            "process-definition": {
+                readonly xml: {
+                    readonly type: "boolean";
+                    readonly description: "Get BPMN XML (process definitions)";
+                    readonly showInTopLevelHelp: true;
+                    readonly helpHint: "use with 'get pd'";
+                };
+            };
+            form: {
+                readonly userTask: {
+                    readonly type: "boolean";
+                    readonly description: "Get form for user task";
+                    readonly showInTopLevelHelp: true;
+                    readonly helpHint: "use with 'get form'";
+                };
+                readonly ut: {
+                    readonly type: "boolean";
+                    readonly description: "Alias for --userTask";
+                };
+                readonly processDefinition: {
+                    readonly type: "boolean";
+                    readonly description: "Get form for process definition";
+                    readonly showInTopLevelHelp: true;
+                    readonly helpHint: "use with 'get form'";
+                };
+                readonly pd: {
+                    readonly type: "boolean";
+                    readonly description: "Alias for --processDefinition";
+                };
+            };
+            "process-instance": {
+                readonly variables: {
+                    readonly type: "boolean";
+                    readonly description: "Include variables in output";
+                    readonly showInTopLevelHelp: true;
+                    readonly helpHint: "use with 'get pi'";
+                };
+            };
+        };
+        resourcePositionals: {
+            "process-definition": readonly [{
+                readonly name: "key";
+                readonly required: true;
+                readonly validate: typeof ProcessDefinitionKey.assumeExists;
+            }];
+            "process-instance": readonly [{
+                readonly name: "key";
+                readonly required: true;
+                readonly validate: typeof ProcessInstanceKey.assumeExists;
+            }];
+            incident: readonly [{
+                readonly name: "key";
+                readonly required: true;
+                readonly validate: typeof IncidentKey.assumeExists;
+            }];
+            user: readonly [{
+                readonly name: "username";
+                readonly required: true;
+                readonly validate: typeof Username.assumeExists;
+            }];
+            role: readonly [{
+                readonly name: "roleId";
+                readonly required: true;
+            }];
+            group: readonly [{
+                readonly name: "groupId";
+                readonly required: true;
+            }];
+            tenant: readonly [{
+                readonly name: "tenantId";
+                readonly required: true;
+                readonly validate: typeof TenantId.assumeExists;
+            }];
+            authorization: readonly [{
+                readonly name: "authorizationKey";
+                readonly required: true;
+                readonly validate: typeof AuthorizationKey.assumeExists;
+            }];
+            "mapping-rule": readonly [{
+                readonly name: "mappingRuleId";
+                readonly required: true;
+            }];
+            form: readonly [{
+                readonly name: "key";
+                readonly required: true;
+            }];
+        };
+    };
+    create: {
+        description: string;
+        helpDescription: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {
+            processDefinitionId: {
+                type: "string";
+                description: string;
+                validate: typeof ProcessDefinitionId.assumeExists;
+            };
+            id: {
+                type: "string";
+                description: string;
+                showInTopLevelHelp: true;
+                helpHint: string;
+            };
+            bpmnProcessId: {
+                type: "string";
+                description: string;
+            };
+            variables: {
+                type: "string";
+                description: string;
+            };
+            awaitCompletion: {
+                type: "boolean";
+                description: string;
+                showInTopLevelHelp: true;
+                helpHint: string;
+            };
+            fetchVariables: {
+                type: "boolean";
+                description: string;
+                showInTopLevelHelp: true;
+            };
+            requestTimeout: {
+                type: "string";
+                description: string;
+                showInTopLevelHelp: true;
+                helpHint: string;
+            };
+            username: {
+                type: "string";
+                description: string;
+                validate: typeof Username.assumeExists;
+            };
+            name: {
+                type: "string";
+                description: string;
+            };
+            email: {
+                type: "string";
+                description: string;
+            };
+            password: {
+                type: "string";
+                description: string;
+            };
+            roleId: {
+                type: "string";
+                description: string;
+            };
+            groupId: {
+                type: "string";
+                description: string;
+            };
+            tenantId: {
+                type: "string";
+                description: string;
+                validate: typeof TenantId.assumeExists;
+            };
+            ownerId: {
+                type: "string";
+                description: string;
+                required: true;
+            };
+            ownerType: {
+                type: "string";
+                description: string;
+                required: true;
+            };
+            resourceType: {
+                type: "string";
+                description: string;
+                required: true;
+            };
+            resourceId: {
+                type: "string";
+                description: string;
+                required: true;
+            };
+            permissions: {
+                type: "string";
+                description: string;
+                required: true;
+                csv: true;
+            };
+            mappingRuleId: {
+                type: "string";
+                description: string;
+            };
+            claimName: {
+                type: "string";
+                description: string;
+            };
+            claimValue: {
+                type: "string";
+                description: string;
+            };
+        };
+    };
+    delete: {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {};
+        resourcePositionals: {
+            user: readonly [{
+                readonly name: "username";
+                readonly required: true;
+                readonly validate: typeof Username.assumeExists;
+            }];
+            role: readonly [{
+                readonly name: "roleId";
+                readonly required: true;
+            }];
+            group: readonly [{
+                readonly name: "groupId";
+                readonly required: true;
+            }];
+            tenant: readonly [{
+                readonly name: "tenantId";
+                readonly required: true;
+                readonly validate: typeof TenantId.assumeExists;
+            }];
+            authorization: readonly [{
+                readonly name: "authorizationKey";
+                readonly required: true;
+                readonly validate: typeof AuthorizationKey.assumeExists;
+            }];
+            "mapping-rule": readonly [{
+                readonly name: "mappingRuleId";
+                readonly required: true;
+            }];
+        };
+    };
+    cancel: {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        resources: string[];
+        flags: {};
+        resourcePositionals: {
+            "process-instance": readonly [{
+                readonly name: "key";
+                readonly required: true;
+                readonly validate: typeof ProcessInstanceKey.assumeExists;
+            }];
+        };
+    };
+    await: {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {
+            processDefinitionId: {
+                type: "string";
+                description: string;
+                validate: typeof ProcessDefinitionId.assumeExists;
+            };
+            id: {
+                type: "string";
+                description: string;
+            };
+            bpmnProcessId: {
+                type: "string";
+                description: string;
+            };
+            variables: {
+                type: "string";
+                description: string;
+            };
+            fetchVariables: {
+                type: "boolean";
+                description: string;
+            };
+            requestTimeout: {
+                type: "string";
+                description: string;
+            };
+        };
+    };
+    complete: {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        resources: string[];
+        flags: {
+            variables: {
+                type: "string";
+                description: string;
+            };
+        };
+        resourcePositionals: {
+            "user-task": readonly [{
+                readonly name: "key";
+                readonly required: true;
+                readonly validate: typeof UserTaskKey.assumeExists;
+            }];
+            job: readonly [{
+                readonly name: "key";
+                readonly required: true;
+                readonly validate: typeof JobKey.assumeExists;
+            }];
+        };
+    };
+    fail: {
+        description: string;
+        helpDescription: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        resources: string[];
+        flags: {
+            retries: {
+                type: "string";
+                description: string;
+            };
+            errorMessage: {
+                type: "string";
+                description: string;
+            };
+        };
+        resourcePositionals: {
+            job: readonly [{
+                readonly name: "key";
+                readonly required: true;
+                readonly validate: typeof JobKey.assumeExists;
+            }];
+        };
+    };
+    activate: {
+        description: string;
+        helpDescription: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        resources: string[];
+        flags: {
+            maxJobsToActivate: {
+                type: "string";
+                description: string;
+            };
+            timeout: {
+                type: "string";
+                description: string;
+            };
+            worker: {
+                type: "string";
+                description: string;
+            };
+        };
+        resourcePositionals: {
+            jobs: readonly [{
+                readonly name: "type";
+                readonly required: true;
+            }];
+        };
+    };
+    resolve: {
+        description: string;
+        helpDescription: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        resources: string[];
+        flags: {};
+        resourcePositionals: {
+            incident: readonly [{
+                readonly name: "key";
+                readonly required: true;
+                readonly validate: typeof IncidentKey.assumeExists;
+            }];
+        };
+    };
+    publish: {
+        description: string;
+        helpDescription: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        resources: string[];
+        flags: {
+            correlationKey: {
+                type: "string";
+                description: string;
+            };
+            variables: {
+                type: "string";
+                description: string;
+            };
+            timeToLive: {
+                type: "string";
+                description: string;
+            };
+        };
+        resourcePositionals: {
+            message: readonly [{
+                readonly name: "name";
+                readonly required: true;
+            }];
+        };
+    };
+    correlate: {
+        description: string;
+        helpDescription: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        resources: string[];
+        flags: {
+            correlationKey: {
+                type: "string";
+                description: string;
+                required: true;
+            };
+            variables: {
+                type: "string";
+                description: string;
+            };
+            timeToLive: {
+                type: "string";
+                description: string;
+            };
+        };
+        resourcePositionals: {
+            message: readonly [{
+                readonly name: "name";
+                readonly required: true;
+            }];
+        };
+    };
+    deploy: {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: false;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: never[];
+        flags: {};
+    };
+    run: {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: never[];
+        flags: {
+            variables: {
+                type: "string";
+                description: string;
+            };
+        };
+    };
+    assign: {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {
+            "to-user": {
+                readonly type: "string";
+                readonly description: "Target user ID";
+            };
+            "to-group": {
+                readonly type: "string";
+                readonly description: "Target group ID";
+            };
+            "to-tenant": {
+                readonly type: "string";
+                readonly description: "Target tenant ID";
+            };
+            "to-mapping-rule": {
+                readonly type: "string";
+                readonly description: "Target mapping rule ID";
+            };
+        };
+        resourcePositionals: {
+            role: readonly [{
+                readonly name: "roleId";
+                readonly required: true;
+            }];
+            user: readonly [{
+                readonly name: "username";
+                readonly required: true;
+                readonly validate: typeof Username.assumeExists;
+            }];
+            group: readonly [{
+                readonly name: "groupId";
+                readonly required: true;
+            }];
+            "mapping-rule": readonly [{
+                readonly name: "mappingRuleId";
+                readonly required: true;
+            }];
+        };
+    };
+    unassign: {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: true;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {
+            "from-user": {
+                readonly type: "string";
+                readonly description: "Source user ID";
+            };
+            "from-group": {
+                readonly type: "string";
+                readonly description: "Source group ID";
+            };
+            "from-tenant": {
+                readonly type: "string";
+                readonly description: "Source tenant ID";
+            };
+            "from-mapping-rule": {
+                readonly type: "string";
+                readonly description: "Source mapping rule ID";
+            };
+        };
+        resourcePositionals: {
+            role: readonly [{
+                readonly name: "roleId";
+                readonly required: true;
+            }];
+            user: readonly [{
+                readonly name: "username";
+                readonly required: true;
+                readonly validate: typeof Username.assumeExists;
+            }];
+            group: readonly [{
+                readonly name: "groupId";
+                readonly required: true;
+            }];
+            "mapping-rule": readonly [{
+                readonly name: "mappingRuleId";
+                readonly required: true;
+            }];
+        };
+    };
+    watch: {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: false;
+        requiresResource: false;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: never[];
+        flags: {
+            force: {
+                type: "boolean";
+                description: string;
+            };
+        };
+        aliases: string[];
+    };
+    open: {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: false;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {};
+    };
+    add: {
+        description: string;
+        mutating: false;
+        requiresResource: true;
+        resources: string[];
+        flags: {
+            baseUrl: {
+                readonly type: "string";
+                readonly description: "Cluster base URL";
+            };
+            clientId: {
+                readonly type: "string";
+                readonly description: "OAuth client ID";
+            };
+            clientSecret: {
+                readonly type: "string";
+                readonly description: "OAuth client secret";
+            };
+            audience: {
+                readonly type: "string";
+                readonly description: "OAuth audience";
+            };
+            oAuthUrl: {
+                readonly type: "string";
+                readonly description: "OAuth token URL";
+            };
+            defaultTenantId: {
+                readonly type: "string";
+                readonly description: "Default tenant ID";
+            };
+            username: {
+                readonly type: "string";
+                readonly description: "Basic auth username";
+            };
+            password: {
+                readonly type: "string";
+                readonly description: "Basic auth password";
+            };
+            "from-file": {
+                readonly type: "string";
+                readonly description: "Import from .env file";
+            };
+            "from-env": {
+                readonly type: "boolean";
+                readonly description: "Import from environment variables";
+            };
+        };
+        resourcePositionals: {
+            profile: readonly [{
+                readonly name: "name";
+                readonly required: true;
+            }];
+        };
+    };
+    remove: {
+        description: string;
+        helpResource: string;
+        helpDescription: string;
+        mutating: false;
+        requiresResource: true;
+        resources: string[];
+        flags: {
+            none: {
+                type: "boolean";
+                description: string;
+            };
+        };
+        aliases: string[];
+        resourcePositionals: {
+            profile: readonly [{
+                readonly name: "name";
+                readonly required: true;
+            }];
+            plugin: readonly [{
+                readonly name: "package";
+                readonly required: true;
+            }];
+        };
+    };
+    load: {
+        description: string;
+        helpResource: string;
+        helpDescription: string;
+        mutating: false;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {
+            from: {
+                type: "string";
+                description: string;
+                showInTopLevelHelp: true;
+                helpHint: string;
+            };
+        };
+        resourcePositionals: {
+            plugin: readonly [{
+                readonly name: "package";
+                readonly required: false;
+            }];
+        };
+    };
+    unload: {
+        description: string;
+        helpResource: string;
+        helpDescription: string;
+        mutating: false;
+        requiresResource: true;
+        resources: string[];
+        flags: {
+            force: {
+                type: "boolean";
+                description: string;
+            };
+        };
+        aliases: string[];
+        resourcePositionals: {
+            plugin: readonly [{
+                readonly name: "package";
+                readonly required: true;
+            }];
+        };
+    };
+    upgrade: {
+        description: string;
+        helpResource: string;
+        helpDescription: string;
+        mutating: false;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {};
+        resourcePositionals: {
+            plugin: readonly [{
+                readonly name: "package";
+                readonly required: true;
+            }, {
+                readonly name: "version";
+                readonly required: false;
+            }];
+        };
+    };
+    downgrade: {
+        description: string;
+        helpResource: string;
+        mutating: false;
+        requiresResource: true;
+        resources: string[];
+        flags: {};
+        resourcePositionals: {
+            plugin: readonly [{
+                readonly name: "package";
+                readonly required: true;
+            }, {
+                readonly name: "version";
+                readonly required: true;
+            }];
+        };
+    };
+    sync: {
+        description: string;
+        helpDescription: string;
+        mutating: false;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {};
+    };
+    init: {
+        description: string;
+        mutating: false;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {};
+        resourcePositionals: {
+            plugin: readonly [{
+                readonly name: "name";
+                readonly required: false;
+            }];
+        };
+    };
+    use: {
+        description: string;
+        helpResource: string;
+        mutating: false;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {
+            none: {
+                type: "boolean";
+                description: string;
+            };
+        };
+        resourcePositionals: {
+            profile: readonly [{
+                readonly name: "name";
+                readonly required: false;
+            }];
+            tenant: readonly [{
+                readonly name: "tenantId";
+                readonly required: true;
+            }];
+        };
+    };
+    output: {
+        description: string;
+        helpResource: string;
+        mutating: false;
+        requiresResource: false;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {};
+    };
+    completion: {
+        description: string;
+        helpResource: string;
+        mutating: true;
+        requiresResource: false;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {};
+        resourceFlags: {
+            install: {
+                shell: {
+                    type: "string";
+                    description: string;
+                };
+            };
+        };
+    };
+    "mcp-proxy": {
+        description: string;
+        helpDescription: string;
+        helpResource: string;
+        hasDetailedHelp: true;
+        helpFooterLabel: string;
+        mutating: false;
+        requiresResource: false;
+        resources: never[];
+        flags: {};
+    };
+    feedback: {
+        description: string;
+        mutating: false;
+        requiresResource: false;
+        resources: never[];
+        flags: {};
+    };
+    help: {
+        description: string;
+        helpResource: string;
+        helpDescription: string;
+        mutating: false;
+        requiresResource: false;
+        resources: never[];
+        flags: {};
+        aliases: string[];
+    };
+    which: {
+        description: string;
+        mutating: false;
+        requiresResource: true;
+        helpExamples: {
+            command: string;
+            description: string;
+        }[];
+        resources: string[];
+        flags: {};
+    };
+};
+/** Union of all known verb names, derived from COMMAND_REGISTRY keys. */
+export type Verb = keyof typeof COMMAND_REGISTRY;
 /**
  * Maps verb aliases to their canonical verb names.
  * Built from COMMAND_REGISTRY aliases fields.
@@ -68,10 +2067,6 @@ export declare function getCommandDef(verb: string): CommandDef | undefined;
  * Get all flags accepted for a given verb, including global flags.
  */
 export declare function getAcceptedFlags(verb: string): Record<string, FlagDef> | undefined;
-/**
- * Get the set of resource-specific search flags for a given canonical resource.
- */
-export declare function getSearchFlagsForResource(resource: string): Set<string> | undefined;
 /**
  * Check whether a verb×resource combination is valid.
  * Accepts both raw aliases and canonical resource names.
@@ -81,6 +2076,11 @@ export declare function isValidCommand(verb: string, resource: string): boolean;
  * Derive parseArgs options from the registry. This produces the flat
  * options object that node:util parseArgs expects, covering all flags
  * from all commands plus global flags.
+ *
+ * When the same flag name appears with different types across commands
+ * (e.g. `--variables` is boolean for `get pi` but string for `create pi`),
+ * "string" wins because parseArgs with `type: "string"` can accept any
+ * value, whereas `type: "boolean"` would discard the string payload.
  */
 export declare function deriveParseArgsOptions(): Record<string, {
     type: "string" | "boolean";