hostctl 0.1.39 → 0.1.41

package/dist/index.d.ts

@@ -154,6 +154,7 @@ declare class Host {
         user: string | undefined;
         tags: string[];
     };
+    effectiveTags(): Set<string>;
     hasTag(tag: string): boolean;
     hasAllTags(tags: Set<string>): boolean;
     hasAnyTag(tags: Set<string>): boolean;
@@ -238,25 +239,51 @@ declare class CommandResult {
     get success(): boolean;
     get failure(): boolean;
 }
+interface CommandOptions {
+    cmd: string;
+    args?: string[];
+    cwd?: string;
+    env?: EnvVarObj;
+    result?: CommandResult;
+    sudo?: boolean;
+}
 declare class Command {
     static parse(commandString: string, env?: EnvVarObj): {
         cmd: string;
         args: string[];
         env?: EnvVarObj;
     };
+    /**
+     * Builds a Command object from a command string or array with optional sudo and environment variables.
+     * This is the main factory method for creating commands that will be executed.
+     */
+    static build(command: string | string[], options?: {
+        sudo?: boolean;
+        env?: EnvVarObj;
+        cwd?: string;
+    }): Command;
     cmd: string;
     args?: string[] | undefined;
     cwd?: string;
     env?: Record<string, string>;
     result?: CommandResult;
-    constructor(opts: {
-        cmd: string;
-        args?: string[];
-        cwd?: string;
-        env?: Record<string, string>;
-        result?: CommandResult;
-    });
+    sudo?: boolean;
+    constructor(opts: CommandOptions);
     isRunning(): boolean;
+    /**
+     * Returns the command as a string suitable for shell execution.
+     * Uses POSIX standard env command for environment variables.
+     */
+    toString(): string;
+    /**
+     * Returns the command and args as separate components.
+     * If env is set, returns env as the command and env assignments as args.
+     * If sudo is set, returns sudo as the command and the rest as args.
+     */
+    toArray(): {
+        cmd: string;
+        args: string[];
+    };
     toJSON(): {
         cmd: string;
         args: string[] | undefined;
@@ -333,13 +360,47 @@ declare class InteractionHandler {
     end(): void;
 }
 
+/**
+ * Generic object type for parameters and return values.
+ */
+type ObjectType = {
+    [key: string]: any;
+};
+/**
+ * Base type for task-specific parameters.
+ */
+type TaskParams = ObjectType;
+/**
+ * Represents the possible return values of a task's run function.
+ */
+type RunFnReturnValue = ObjectType | void | undefined | null | Error;
+/**
+ * Defines the signature of a task's main execution function.
+ * It receives a TaskContext and returns a Promise of a RunFnReturnValue.
+ */
+interface RunFn<TParams extends TaskParams = TaskParams, TReturn extends RunFnReturnValue = RunFnReturnValue> {
+    (context: TaskContext<TParams>): Promise<TReturn>;
+}
+/**
+ * Represents a task definition, including its run function and metadata.
+ * This class is instantiated by the `task` factory function.
+ */
+declare class Task<TParams extends TaskParams = TaskParams, TReturn extends RunFnReturnValue = RunFnReturnValue> {
+    runFn: RunFn<TParams, TReturn>;
+    taskModuleAbsolutePath?: string | undefined;
+    description?: string | undefined;
+    name?: string | undefined;
+    constructor(runFn: RunFn<TParams, TReturn>, taskModuleAbsolutePath?: string | undefined, description?: string | undefined, name?: string | undefined);
+}
+
 type LogLevel = number;
 interface FileSystemOperations$1 {
     read: (path: string) => Promise<string>;
-    write: (path: string, content: string, options?: {
+    write: (path: string, content: string | Buffer, options?: {
         mode?: string | number;
         user?: string;
         group?: string;
+        flag?: string;
     }) => Promise<void>;
     exists: (path: string) => Promise<boolean>;
     mkdir: (path: string, options?: {
@@ -376,6 +437,7 @@ interface TaskContext<TParams extends TaskParams = TaskParams> {
     getSecret: (name: string) => Promise<string | undefined>;
     exit: (exitCode: number, message?: string) => void;
     inventory: (tags: string[]) => Host[];
+    selectedInventory: (tags?: string[]) => Host[];
     file: FileSystemOperations$1;
 }
 type TaskPartialFn<TReturn extends RunFnReturnValue = RunFnReturnValue> = (parentInvocation: IInvocation) => Promise<TReturn>;
@@ -414,6 +476,7 @@ interface IInvocation<TParams extends TaskParams = any> {
     getSecret(name: string): Promise<string | undefined>;
     exit(exitCode: number, message?: string): void;
     inventory(tags: string[]): Host[];
+    selectedInventory(tags?: string[]): Host[];
     setDescription(description: string): void;
     setFutureResult(resultPromise: Promise<RunFnReturnValue>): void;
     appendChildInvocation(childInvocation: IInvocation<any>): Promise<void>;
@@ -455,6 +518,7 @@ declare abstract class Invocation<TParams extends TaskParams = any> implements I
     getResultPromise(): Promise<RunFnReturnValue>;
     exit(exitCode: number, message?: string): void;
     inventory(tags: string[]): Host[];
+    selectedInventory(tags?: string[]): Host[];
     appendChildInvocation(childInvocation: IInvocation<any>): Promise<void>;
     abstract readonly config: AppConfig;
     abstract log(level: LogLevel, ...message: any[]): void;
@@ -485,48 +549,17 @@ interface IRuntime {
     getTmpDir(): Path;
     getTmpFile(prefix?: string, postfix?: string, dir?: Path): Path;
     inventory(tags: string[]): Host[];
+    selectedInventory(tags?: string[]): Host[];
     invokeRootTask<TParams extends TaskParams, TReturn extends RunFnReturnValue>(taskFnDefinition: TaskFn<TParams, TReturn>, params: TParams, description?: string): Promise<IInvocation<TParams>>;
 }
 
-/**
- * Generic object type for parameters and return values.
- */
-type ObjectType = {
-    [key: string]: any;
-};
-/**
- * Base type for task-specific parameters.
- */
-type TaskParams = ObjectType;
-/**
- * Represents the possible return values of a task's run function.
- */
-type RunFnReturnValue = ObjectType | void | undefined | null | Error;
-/**
- * Defines the signature of a task's main execution function.
- * It receives a TaskContext and returns a Promise of a RunFnReturnValue.
- */
-interface RunFn<TParams extends TaskParams = TaskParams, TReturn extends RunFnReturnValue = RunFnReturnValue> {
-    (context: TaskContext<TParams>): Promise<TReturn>;
-}
-/**
- * Represents a task definition, including its run function and metadata.
- * This class is instantiated by the `task` factory function.
- */
-declare class Task<TParams extends TaskParams = TaskParams, TReturn extends RunFnReturnValue = RunFnReturnValue> {
-    runFn: RunFn<TParams, TReturn>;
-    taskModuleAbsolutePath?: string | undefined;
-    description?: string | undefined;
-    name?: string | undefined;
-    constructor(runFn: RunFn<TParams, TReturn>, taskModuleAbsolutePath?: string | undefined, description?: string | undefined, name?: string | undefined);
-}
-
 interface FileSystemOperations {
     read: (path: string) => Promise<string>;
-    write: (path: string, content: string, options?: {
+    write: (path: string, content: string | Buffer, options?: {
         mode?: string | number | undefined;
         user?: string | undefined;
         group?: string | undefined;
+        flag?: string | undefined;
     }) => Promise<void>;
     exists: (path: string) => Promise<boolean>;
     mkdir: (path: string, options?: {
@@ -557,7 +590,6 @@ declare class LocalInvocation<TParams extends TaskParams, TReturn extends RunFnR
     ssh<TRemoteParams extends TaskParams = {}, TRemoteReturn extends RunFnReturnValue = RunFnReturnValue>(tags: string[], remoteTaskFn: (remoteContext: TaskContext<TRemoteParams>) => Promise<TRemoteReturn>): Promise<Record<string, TRemoteReturn | Error>>;
     runRemoteTaskOnHost<TRemoteParams extends TaskParams, TRemoteReturn extends RunFnReturnValue>(host: Host, remoteTaskFn: RunFn<TRemoteParams, TRemoteReturn>): Promise<TRemoteReturn | Error>;
     exit(exitCode: number, message?: string): void;
-    inventory(tags: string[]): Host[];
     run<TRunReturn extends RunFnReturnValue>(taskPartialFn: TaskPartialFn<TRunReturn>): Promise<TRunReturn>;
     invokeChildTask<TTaskParams extends TaskParams, TTaskReturn extends RunFnReturnValue>(childTaskFnDefinition: TaskFn<TTaskParams, TTaskReturn>, params: TTaskParams): Promise<TTaskReturn>;
 }
@@ -578,34 +610,18 @@ declare class LocalRuntime implements IRuntime {
     getTmpDir(): Path;
     getTmpFile(prefix?: string | undefined, postfix?: string | undefined, dir?: Path | undefined): Path;
     inventory(tags: string[]): Host[];
+    selectedInventory(tags?: string[]): Host[];
     invokeRootTask<TParams extends TaskParams, TReturn extends RunFnReturnValue>(taskFnDefinition: TaskFn<TParams, TReturn>, params: TParams, description?: string): Promise<LocalInvocation<TParams, TReturn>>;
 }
 
-declare class RemoteRuntime implements IRuntime {
-    private sftpClientInstance?;
-    readonly app: App;
-    readonly host: Host;
-    readonly interactionHandler: InteractionHandler;
-    private sshSession;
-    constructor(app: App, host: Host, _localRuntime: LocalRuntime, interactionHandler?: InteractionHandler);
-    get tmpDirRootPath(): Path;
-    getPassword(): Promise<string | undefined>;
-    getSecret(name: string): Promise<string | undefined>;
-    getTmpDir(): Path;
-    getTmpFile(prefix?: string | undefined, postfix?: string | undefined, dir?: Path | undefined): Path;
-    inventory(tags: string[]): Host[];
-    connect(): Promise<boolean>;
-    getSftpClient(): Promise<any>;
-    executeCommand(command: string | string[], options?: {
-        cwd?: string;
-        stdin?: string | Buffer;
-        pty?: boolean;
-        env?: Record<string, string>;
-        interactionHandler?: InteractionHandler;
-    }): Promise<Command | Error>;
-    disconnect(): Promise<void>;
-    invokeRootTask<TParams extends TaskParams, TReturn extends RunFnReturnValue>(taskFnDefinition: TaskFn<TParams, TReturn>, params: TParams): Promise<IInvocation>;
-}
+declare const Verbosity: {
+    readonly ERROR: 0;
+    readonly WARN: 1;
+    readonly INFO: 2;
+    readonly DEBUG: 3;
+    readonly TRACE: 4;
+};
+type VerbosityLevel = (typeof Verbosity)[keyof typeof Verbosity];
 
 type AppConfig = Config;
 
@@ -629,14 +645,42 @@ declare class TaskTree {
     getWithTimeout(id: string): Promise<TaskTreeNode | undefined>;
     run(ctx?: any): Promise<any>;
 }
-declare const Verbosity: {
-    ERROR: number;
-    WARN: number;
-    INFO: number;
-    DEBUG: number;
-    TRACE: number;
-};
+interface LoadAppOptions {
+    /** Optional configuration file path or URL */
+    config?: string;
+    /** Optional verbosity level (0-4, where 0 is error only, 4 is trace) */
+    verbosity?: number;
+    /** Optional output style (plain, json, api) */
+    outputStyle?: 'plain' | 'json' | 'api';
+}
+interface ExecuteResult {
+    /** Overall success indicator - true if all hosts succeeded */
+    success: boolean;
+    /** Results for each host, keyed by hostname */
+    hosts: Record<string, {
+        /** Host alias if available */
+        alias: string;
+        /** Whether the command succeeded on this host */
+        success: boolean;
+        /** Command output */
+        stdout: string;
+        /** Command error output */
+        stderr: string;
+        /** Exit code */
+        exitCode: number;
+        /** Signal if the process was terminated by a signal */
+        signal?: string;
+    }>;
+    /** Total number of hosts that were targeted */
+    totalHosts: number;
+    /** Number of hosts that succeeded */
+    successfulHosts: number;
+    /** Number of hosts that failed */
+    failedHosts: number;
+}
 declare class App {
+    static loadApiMode(options: LoadAppOptions): Promise<App>;
+    static load(options: LoadAppOptions): Promise<App>;
     configRef?: string;
     private _config?;
     selectedTags: Set<string>;
@@ -644,12 +688,14 @@ declare class App {
     private _tmpDir?;
     private tmpFileRegistry;
     taskTree: TaskTree;
-    verbosity: number;
+    verbosity: VerbosityLevel;
     constructor();
     appExitCallback(): void;
     get config(): Config;
     get tmpDir(): Path;
-    loadConfig(configString?: string): Promise<void>;
+    loadConfig(configRef?: string): Promise<void>;
+    isValidUrl(url: string): boolean;
+    deriveConfigRef(configRef?: string): string;
     log(level: LogLevel, ...args: any[]): void;
     debug(...args: any[]): void;
     info(...args: any[]): void;
@@ -666,24 +712,41 @@ declare class App {
     shouldRunRemote(): boolean;
     logHostCommandResult(host: Host, command: string | string[], cmdOrErr: Command | Error, isErrorResult?: boolean): void;
     defaultSshUser(): string | undefined;
-    execute(cmd: string | string[]): Promise<boolean>;
+    execute(cmd: string | string[]): Promise<ExecuteResult>;
     runRemote(host: Host, cmd: string | string[]): Promise<Command | Error>;
+    /**
+   * Builds the hosts record from host result quads
+   */
+    private buildHostsRecord;
+    /**
+     * Counts successful and failed hosts from host result quads
+     */
+    private countHostResults;
+    /**
+     * Determines overall success from host result quads
+     */
+    private determineOverallSuccess;
+    /**
+     * Constructs the detailed ExecuteResult from host result quads and total host count
+     */
+    private buildExecuteResult;
     getSecretsForHost(hostId: string): Map<string | RegExp, string>;
     taskContextForRunFn<TParams extends TaskParams>(invocation: IInvocation<TParams>, params: TParams, hostForContext?: Host): TaskContext<TParams>;
     setSelectedTags(selectedTags: string[]): void;
-    setOutputStyle(outputStyle: 'plain' | 'json'): void;
-    setVerbosity(level: number): void;
+    setOutputStyle(outputStyle: 'plain' | 'json' | 'api'): void;
+    setVerbosity(level: number): VerbosityLevel;
+    outputApiMode(): boolean;
     outputJson(): boolean;
     outputPlain(): boolean;
-    querySelectedInventory(tags?: string[]): Host[];
+    querySelectedInventory(tags?: Set<string>): Host[];
     selectedInventory(): Host[];
     queryInventory(tags?: Set<string>): Host[];
     selectInventory(hosts: Host[], tags?: Set<string>): Host[];
     printInventoryReport(): void;
     encryptInventoryFile(): Promise<void>;
     decryptInventoryFile(): Promise<void>;
-    runScript(scriptRef: string, params: TaskParams): Promise<void>;
-    runScriptRemote(scriptRef: string, params: TaskParams): Promise<void>;
+    runScript(scriptRef: string, params: TaskParams): Promise<RunFnReturnValue>;
+    runScriptRemote(scriptRef: string, params: TaskParams): Promise<RunFnReturnValue>;
     walkInvocationTreePreorder(invocation: IInvocation<any>, visitFn: (invocation: IInvocation<any>, depth: number) => Promise<void>, visited?: Set<IInvocation<any>>, depth?: number): Promise<void>;
     reportScriptResult(invocation: LocalInvocation<any, any>, scriptResult: RunFnReturnValue | Error): Promise<void>;
     loadScriptAsModule(scriptRef: string): Promise<any>;
@@ -692,7 +755,39 @@ declare class App {
     printRuntimeReport(): Promise<void>;
     promptPassword(message?: string): Promise<string>;
     installRuntime(): Promise<void>;
-    bootstrap(): Promise<void>;
+    /**
+     * Executes a command on the selected hosts
+     *
+     * @param options - Configuration options for running the task
+     * @returns Promise resolving to the task's result
+     */
+    apiExecute(options: {
+        /** The host tags to scope the run to */
+        hostTags?: string[];
+        /** The command to execute */
+        command: string | string[];
+    }): Promise<ExecuteResult>;
+    /**
+     * Resolves a task from a package reference and runs it
+     *
+     * This method provides a simple way to resolve and execute tasks using the same
+     * logic as the CLI, but as a method on an App instance.
+     *
+     * @param options - Configuration options for running the task
+     * @returns Promise resolving to the task's result
+     */
+    apiRunTask(options: {
+        /** Whether to run the task remotely (if not provided, runs locally) */
+        remote?: boolean;
+        /** The host tags to scope the run to */
+        hostTags?: string[];
+        /** The package reference (core task, local path, or remote package) */
+        package: string;
+        /** Optional task name within the package */
+        task?: string;
+        /** Parameters to pass to the task */
+        params: TaskParams;
+    }): Promise<RunFnReturnValue>;
 }
 
 declare class Cli {
@@ -704,7 +799,7 @@ declare class Cli {
     handleInventoryDecrypt(options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
     handleInventoryList(options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
     handleExec(commandParts: string | string[], options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
-    handleRun(packageRef: string | null, scriptRef: string | undefined, scriptArgs: string[], options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
+    handleRun(pkgTaskArgs: string[], options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
     deriveConfigRef(suppliedConfigRef?: string): string;
     loadApp(opts: Record<string, any>): Promise<void>;
     run(): Promise<void>;
@@ -722,6 +817,15 @@ interface WhoamiParams {
 }
 interface WhoamiResult {
     user: string;
+    success: boolean;
+    error?: string;
+}
+
+type EnvParams = {};
+interface EnvResult {
+    env: Record<string, string>;
+    success: boolean;
+    error?: string;
 }
 
 type EchoParams = {
@@ -729,6 +833,8 @@ type EchoParams = {
 };
 interface EchoResult {
     stdout: string;
+    success: boolean;
+    error?: string;
 }
 
 interface DirExistsParams {
@@ -736,8 +842,10 @@ interface DirExistsParams {
 }
 interface DirExistsResult {
     exists: boolean;
+    success: boolean;
+    error?: string;
 }
-declare const _default$16: TaskFn<DirExistsParams, DirExistsResult>;
+declare const _default$3x: TaskFn<DirExistsParams, DirExistsResult>;
 
 interface DirCopyParams {
     from: string;
@@ -749,8 +857,9 @@ interface DirCopyParams {
 }
 interface DirCopyResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$15: TaskFn<DirCopyParams, DirCopyResult>;
+declare const _default$3w: TaskFn<DirCopyParams, DirCopyResult>;
 
 interface DirCreateParams {
     path: string;
@@ -759,11 +868,12 @@ interface DirCreateParams {
 }
 interface DirCreateResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$14: TaskFn<DirCreateParams, DirCreateResult>;
+declare const _default$3v: TaskFn<DirCreateParams, DirCreateResult>;
 
 declare namespace dir {
-  export { _default$15 as copy, _default$14 as create, _default$16 as exists };
+  export { _default$3w as copy, _default$3v as create, _default$3x as exists };
 }
 
 interface ChownParams {
@@ -777,7 +887,7 @@ interface ChownResult {
     success: boolean;
     error?: string;
 }
-declare const _default$13: TaskFn<ChownParams, ChownResult>;
+declare const _default$3u: TaskFn<ChownParams, ChownResult>;
 
 interface ChgrpParams {
     path: string;
@@ -789,7 +899,7 @@ interface ChgrpResult {
     success: boolean;
     error?: string;
 }
-declare const _default$12: TaskFn<ChgrpParams, ChgrpResult>;
+declare const _default$3t: TaskFn<ChgrpParams, ChgrpResult>;
 
 interface ChmodParams {
     path: string;
@@ -801,7 +911,7 @@ interface ChmodResult {
     success: boolean;
     error?: string;
 }
-declare const _default$11: TaskFn<ChmodParams, ChmodResult>;
+declare const _default$3s: TaskFn<ChmodParams, ChmodResult>;
 
 interface FileCopyParams {
     from: string;
@@ -814,16 +924,19 @@ interface FileCopyParams {
 }
 interface FileCopyResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$10: TaskFn<FileCopyParams, FileCopyResult>;
+declare const _default$3r: TaskFn<FileCopyParams, FileCopyResult>;
 
 interface FileExistsParams {
     path: string;
 }
 interface FileExistsResult {
     exists: boolean;
+    success: boolean;
+    error?: string;
 }
-declare const _default$$: TaskFn<FileExistsParams, FileExistsResult>;
+declare const _default$3q: TaskFn<FileExistsParams, FileExistsResult>;
 
 interface FileTouchParams {
     file: string;
@@ -832,8 +945,9 @@ interface FileTouchParams {
 }
 interface FileTouchResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$_: TaskFn<FileTouchParams, FileTouchResult>;
+declare const _default$3p: TaskFn<FileTouchParams, FileTouchResult>;
 
 interface FileDeleteParams {
     path: string;
@@ -842,8 +956,9 @@ interface FileDeleteParams {
 }
 interface FileDeleteResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$Z: TaskFn<FileDeleteParams, FileDeleteResult>;
+declare const _default$3o: TaskFn<FileDeleteParams, FileDeleteResult>;
 
 interface FileLinkParams {
     /** Path the symlink should point TO (target). */
@@ -858,8 +973,9 @@ interface FileLinkParams {
 interface FileLinkResult {
     changed: boolean;
     success: boolean;
+    error?: string;
 }
-declare const _default$Y: TaskFn<FileLinkParams, FileLinkResult>;
+declare const _default$3n: TaskFn<FileLinkParams, FileLinkResult>;
 
 interface FileEditParams {
     file: string;
@@ -878,8 +994,9 @@ interface FileEditParams {
 interface FileEditResult {
     changed: boolean;
     success: boolean;
+    error?: string;
 }
-declare const _default$X: TaskFn<FileEditParams, FileEditResult>;
+declare const _default$3m: TaskFn<FileEditParams, FileEditResult>;
 
 interface FileGrepParams {
     /** Path to the file to search */
@@ -914,8 +1031,12 @@ interface FileGrepResult {
     count: number;
     /** Matching lines (included only when return_lines=true) */
     lines?: string[];
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Error message if operation failed */
+    error?: string;
 }
-declare const _default$W: TaskFn<FileGrepParams, FileGrepResult>;
+declare const _default$3l: TaskFn<FileGrepParams, FileGrepResult>;
 
 type file_ChgrpParams = ChgrpParams;
 type file_ChgrpResult = ChgrpResult;
@@ -938,7 +1059,7 @@ type file_FileLinkResult = FileLinkResult;
 type file_FileTouchParams = FileTouchParams;
 type file_FileTouchResult = FileTouchResult;
 declare namespace file {
-  export { type file_ChgrpParams as ChgrpParams, type file_ChgrpResult as ChgrpResult, type file_ChmodParams as ChmodParams, type file_ChmodResult as ChmodResult, type file_ChownParams as ChownParams, type file_ChownResult as ChownResult, type file_FileCopyParams as FileCopyParams, type file_FileCopyResult as FileCopyResult, type file_FileDeleteParams as FileDeleteParams, type file_FileDeleteResult as FileDeleteResult, type file_FileEditParams as FileEditParams, type file_FileEditResult as FileEditResult, type file_FileExistsParams as FileExistsParams, type file_FileExistsResult as FileExistsResult, type file_FileGrepParams as FileGrepParams, type file_FileGrepResult as FileGrepResult, type file_FileLinkParams as FileLinkParams, type file_FileLinkResult as FileLinkResult, type file_FileTouchParams as FileTouchParams, type file_FileTouchResult as FileTouchResult, _default$12 as chgrp, _default$11 as chmod, _default$13 as chown, _default$10 as copy, _default$Z as delete, _default$X as edit, _default$$ as exists, _default$W as grep, _default$Y as link, _default$_ as touch };
+  export { type file_ChgrpParams as ChgrpParams, type file_ChgrpResult as ChgrpResult, type file_ChmodParams as ChmodParams, type file_ChmodResult as ChmodResult, type file_ChownParams as ChownParams, type file_ChownResult as ChownResult, type file_FileCopyParams as FileCopyParams, type file_FileCopyResult as FileCopyResult, type file_FileDeleteParams as FileDeleteParams, type file_FileDeleteResult as FileDeleteResult, type file_FileEditParams as FileEditParams, type file_FileEditResult as FileEditResult, type file_FileExistsParams as FileExistsParams, type file_FileExistsResult as FileExistsResult, type file_FileGrepParams as FileGrepParams, type file_FileGrepResult as FileGrepResult, type file_FileLinkParams as FileLinkParams, type file_FileLinkResult as FileLinkResult, type file_FileTouchParams as FileTouchParams, type file_FileTouchResult as FileTouchResult, _default$3t as chgrp, _default$3s as chmod, _default$3u as chown, _default$3r as copy, _default$3o as delete, _default$3m as edit, _default$3q as exists, _default$3l as grep, _default$3n as link, _default$3p as touch };
 }
 
 interface GitCloneParams {
@@ -947,8 +1068,9 @@ interface GitCloneParams {
 }
 interface GitCloneResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$V: TaskFn<GitCloneParams, GitCloneResult>;
+declare const _default$3k: TaskFn<GitCloneParams, GitCloneResult>;
 
 interface GitPullParams {
     /** The directory of the git repository on the host. */
@@ -966,7 +1088,7 @@ interface GitPullResult {
     /** Error message if the pull operation failed. */
     error?: string;
 }
-declare const _default$U: TaskFn<GitPullParams, GitPullResult>;
+declare const _default$3j: TaskFn<GitPullParams, GitPullResult>;
 
 interface GitCheckoutParams {
     /** The directory of the git repository on the host. */
@@ -982,7 +1104,7 @@ interface GitCheckoutResult {
     /** Error message if the checkout operation failed. */
     error?: string;
 }
-declare const _default$T: TaskFn<GitCheckoutParams, GitCheckoutResult>;
+declare const _default$3i: TaskFn<GitCheckoutParams, GitCheckoutResult>;
 
 type git_GitCheckoutParams = GitCheckoutParams;
 type git_GitCheckoutResult = GitCheckoutResult;
@@ -991,7 +1113,7 @@ type git_GitCloneResult = GitCloneResult;
 type git_GitPullParams = GitPullParams;
 type git_GitPullResult = GitPullResult;
 declare namespace git {
-  export { type git_GitCheckoutParams as GitCheckoutParams, type git_GitCheckoutResult as GitCheckoutResult, type git_GitCloneParams as GitCloneParams, type git_GitCloneResult as GitCloneResult, type git_GitPullParams as GitPullParams, type git_GitPullResult as GitPullResult, _default$T as checkout, _default$V as clone, _default$U as pull };
+  export { type git_GitCheckoutParams as GitCheckoutParams, type git_GitCheckoutResult as GitCheckoutResult, type git_GitCloneParams as GitCloneParams, type git_GitCloneResult as GitCloneResult, type git_GitPullParams as GitPullParams, type git_GitPullResult as GitPullResult, _default$3i as checkout, _default$3k as clone, _default$3j as pull };
 }
 
 interface GroupCreateParams {
@@ -1001,8 +1123,9 @@ interface GroupCreateParams {
 }
 interface GroupCreateResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$S: TaskFn<GroupCreateParams, GroupCreateResult>;
+declare const _default$3h: TaskFn<GroupCreateParams, GroupCreateResult>;
 
 interface GroupDeleteParams {
     group: string;
@@ -1013,7 +1136,7 @@ interface GroupDeleteResult {
     success: boolean;
     error?: string;
 }
-declare const _default$R: TaskFn<GroupDeleteParams, GroupDeleteResult>;
+declare const _default$3g: TaskFn<GroupDeleteParams, GroupDeleteResult>;
 
 interface GroupExistsParams {
     group: string;
@@ -1021,7 +1144,7 @@ interface GroupExistsParams {
 interface GroupExistsResult {
     exists: boolean;
 }
-declare const _default$Q: TaskFn<GroupExistsParams, GroupExistsResult>;
+declare const _default$3f: TaskFn<GroupExistsParams, GroupExistsResult>;
 
 interface GroupInfo {
     name: string;
@@ -1031,9 +1154,10 @@ interface GroupListParams {
 }
 interface GroupListResult {
     success: boolean;
+    error?: string;
     groups: GroupInfo[];
 }
-declare const _default$P: TaskFn<GroupListParams, GroupListResult>;
+declare const _default$3e: TaskFn<GroupListParams, GroupListResult>;
 
 interface GroupModifyParams {
     /** The current name of the group. */
@@ -1050,7 +1174,7 @@ interface GroupModifyResult {
     changed: boolean;
     error?: string;
 }
-declare const _default$O: TaskFn<GroupModifyParams, GroupModifyResult>;
+declare const _default$3d: TaskFn<GroupModifyParams, GroupModifyResult>;
 
 type group_GroupCreateParams = GroupCreateParams;
 type group_GroupCreateResult = GroupCreateResult;
@@ -1064,7 +1188,7 @@ type group_GroupListResult = GroupListResult;
 type group_GroupModifyParams = GroupModifyParams;
 type group_GroupModifyResult = GroupModifyResult;
 declare namespace group {
-  export { type group_GroupCreateParams as GroupCreateParams, type group_GroupCreateResult as GroupCreateResult, type group_GroupDeleteParams as GroupDeleteParams, type group_GroupDeleteResult as GroupDeleteResult, type group_GroupExistsParams as GroupExistsParams, type group_GroupExistsResult as GroupExistsResult, type group_GroupInfo as GroupInfo, type group_GroupListParams as GroupListParams, type group_GroupListResult as GroupListResult, type group_GroupModifyParams as GroupModifyParams, type group_GroupModifyResult as GroupModifyResult, _default$S as create, _default$R as delete, _default$Q as exists, _default$P as list, _default$O as modify };
+  export { type group_GroupCreateParams as GroupCreateParams, type group_GroupCreateResult as GroupCreateResult, type group_GroupDeleteParams as GroupDeleteParams, type group_GroupDeleteResult as GroupDeleteResult, type group_GroupExistsParams as GroupExistsParams, type group_GroupExistsResult as GroupExistsResult, type group_GroupInfo as GroupInfo, type group_GroupListParams as GroupListParams, type group_GroupListResult as GroupListResult, type group_GroupModifyParams as GroupModifyParams, type group_GroupModifyResult as GroupModifyResult, _default$3h as create, _default$3g as delete, _default$3f as exists, _default$3e as list, _default$3d as modify };
 }
 
 interface OSInfo {
@@ -1098,13 +1222,15 @@ interface HostSummary {
 
 interface HostInfoResult {
     host: HostInfo;
+    success: boolean;
+    error?: string;
 }
-declare const _default$N: TaskFn<ObjectType, HostInfoResult>;
+declare const _default$3c: TaskFn<ObjectType, HostInfoResult>;
 
 interface HostSummaryResult {
     host: HostSummary;
 }
-declare const _default$M: TaskFn<ObjectType, HostSummaryResult>;
+declare const _default$3b: TaskFn<ObjectType, HostSummaryResult>;
 
 interface OsDetailsResult {
     success: boolean;
@@ -1121,7 +1247,7 @@ interface OsDetailsResult {
  * Determines the operating system family, specific OS, variant, and version.
  * @returns {OsDetailsResult}
  */
-declare const _default$L: TaskFn<ObjectType, OsDetailsResult>;
+declare const _default$3a: TaskFn<ObjectType, OsDetailsResult>;
 
 interface HostnameParams {
     new_name?: string;
@@ -1129,8 +1255,10 @@ interface HostnameParams {
 interface HostnameResult {
     hostname: string;
     updated: boolean;
+    success: boolean;
+    error?: string;
 }
-declare const _default$K: TaskFn<HostnameParams, HostnameResult>;
+declare const _default$39: TaskFn<HostnameParams, HostnameResult>;
 
 type host_HostInfo = HostInfo;
 type host_HostInfoResult = HostInfoResult;
@@ -1143,7 +1271,7 @@ type host_LSCPUChild = LSCPUChild;
 type host_OSInfo = OSInfo;
 type host_OsDetailsResult = OsDetailsResult;
 declare namespace host {
-  export { type host_HostInfo as HostInfo, type host_HostInfoResult as HostInfoResult, type host_HostSummary as HostSummary, type host_HostSummaryResult as HostSummaryResult, type host_HostnameParams as HostnameParams, type host_HostnameResult as HostnameResult, type host_LSBRelease as LSBRelease, type host_LSCPUChild as LSCPUChild, type host_OSInfo as OSInfo, type host_OsDetailsResult as OsDetailsResult, _default$K as hostname, _default$N as info, _default$L as os, _default$M as summary };
+  export { type host_HostInfo as HostInfo, type host_HostInfoResult as HostInfoResult, type host_HostSummary as HostSummary, type host_HostSummaryResult as HostSummaryResult, type host_HostnameParams as HostnameParams, type host_HostnameResult as HostnameResult, type host_LSBRelease as LSBRelease, type host_LSCPUChild as LSCPUChild, type host_OSInfo as OSInfo, type host_OsDetailsResult as OsDetailsResult, _default$39 as hostname, _default$3c as info, _default$3a as os, _default$3b as summary };
 }
 
 interface AbstractPkgParams {
@@ -1155,6 +1283,11 @@ interface AbstractPkgParams {
     packageManager?: string;
     /** Additional arguments to pass to the package manager */
     extraArgs?: string;
+    /**
+     * Map of interactive prompt patterns to responses. If a prompt matching a pattern appears during installation,
+     * the corresponding response will be sent to stdin. Merged with default patterns for common package manager prompts.
+     */
+    input?: Record<string, string>;
 }
 interface AbstractPkgResult {
     success: boolean;
@@ -1162,6 +1295,9 @@ interface AbstractPkgResult {
     packageManager?: string;
     output?: string;
     packages?: AbstractPkgInfo[];
+    removed?: string[];
+    notInstalled?: string[];
+    failed?: string[];
 }
 interface AbstractPkgInfo {
     name: string;
@@ -1170,12 +1306,48 @@ interface AbstractPkgInfo {
     status?: string;
     [key: string]: any;
 }
+interface AbstractPkgCleanResult extends AbstractPkgResult {
+}
+interface AbstractPkgCleanParams {
+    /** Force use of specific package manager (auto-detect if not specified) */
+    packageManager?: string;
+    /** Whether to run the command with sudo */
+    sudo?: boolean;
+}
 
 interface AbstractPkgInstallParams extends AbstractPkgParams {
 }
 interface AbstractPkgInstallResult extends AbstractPkgResult {
 }
-declare const _default$J: TaskFn<AbstractPkgInstallParams, AbstractPkgInstallResult>;
+declare const _default$38: TaskFn<AbstractPkgInstallParams, AbstractPkgInstallResult>;
+
+interface AbstractPkgUninstallParams extends AbstractPkgParams {
+}
+interface AbstractPkgUninstallResult extends AbstractPkgResult {
+}
+declare const _default$37: TaskFn<AbstractPkgUninstallParams, AbstractPkgUninstallResult>;
+
+interface AbstractPkgUpdateParams {
+    /** Run commands with sudo (default true) */
+    sudo?: boolean;
+    /** Force use of specific package manager (auto-detect if not specified) */
+    packageManager?: string;
+    /** Additional arguments to pass to the package manager */
+    extraArgs?: string;
+}
+interface AbstractPkgUpdateResult extends AbstractPkgResult {
+}
+declare const _default$36: TaskFn<AbstractPkgUpdateParams, AbstractPkgUpdateResult>;
+
+interface PkgInfoParams {
+    package: string;
+}
+interface PkgInfoResult {
+    installed: boolean;
+    success: boolean;
+    error?: string;
+}
+declare const _default$35: TaskFn<PkgInfoParams, PkgInfoResult>;
 
 interface BasePkgParams {
     /** Package name or array of package names */
@@ -1211,44 +1383,18 @@ interface PkgIsInstalledParams {
     package: string;
 }
 interface PkgIsInstalledResult {
-    installed: boolean;
-}
-
-declare const _default$I: TaskFn<PkgRemoveParams, PkgRemoveResult>;
-
-declare const _default$H: TaskFn<PkgUpdateParams, PkgUpdateResult>;
-
-interface PkgInfoParams {
-    package: string;
-}
-interface PkgInfoResult {
-    installed: boolean;
     success: boolean;
+    installed: boolean;
     error?: string;
 }
-declare const _default$G: TaskFn<PkgInfoParams, PkgInfoResult>;
 
-declare const _default$F: TaskFn<PkgIsInstalledParams, PkgIsInstalledResult>;
+declare const _default$34: TaskFn<PkgIsInstalledParams, PkgIsInstalledResult>;
 
-declare const _default$E: TaskFn<PkgInstallParams, PkgInstallResult>;
+declare const install: TaskFn<PkgInstallParams, PkgInstallResult>;
 
-interface AbstractPkgUninstallParams extends AbstractPkgParams {
-}
-interface AbstractPkgUninstallResult extends AbstractPkgResult {
-}
-declare const _default$D: TaskFn<AbstractPkgUninstallParams, AbstractPkgUninstallResult>;
+declare const _default$33: TaskFn<PkgRemoveParams, PkgRemoveResult>;
 
-interface AbstractPkgUpdateParams {
-    /** Run commands with sudo (default true) */
-    sudo?: boolean;
-    /** Force use of specific package manager (auto-detect if not specified) */
-    packageManager?: string;
-    /** Additional arguments to pass to the package manager */
-    extraArgs?: string;
-}
-interface AbstractPkgUpdateResult extends AbstractPkgResult {
-}
-declare const _default$C: TaskFn<AbstractPkgUpdateParams, AbstractPkgUpdateResult>;
+declare const _default$32: TaskFn<PkgUpdateParams, PkgUpdateResult>;
 
 interface AbstractPkgUpgradeParams {
     /** Run commands with sudo (default true) */
@@ -1260,7 +1406,7 @@ interface AbstractPkgUpgradeParams {
 }
 interface AbstractPkgUpgradeResult extends AbstractPkgResult {
 }
-declare const _default$B: TaskFn<AbstractPkgUpgradeParams, AbstractPkgUpgradeResult>;
+declare const _default$31: TaskFn<AbstractPkgUpgradeParams, AbstractPkgUpgradeResult>;
 
 interface AbstractPkgSearchParams {
     /** Search query */
@@ -1270,7 +1416,7 @@ interface AbstractPkgSearchParams {
 }
 interface AbstractPkgSearchResult extends AbstractPkgResult {
 }
-declare const _default$A: TaskFn<AbstractPkgSearchParams, AbstractPkgSearchResult>;
+declare const _default$30: TaskFn<AbstractPkgSearchParams, AbstractPkgSearchResult>;
 
 interface AbstractPkgListParams {
     /** Force use of specific package manager (auto-detect if not specified) */
@@ -1278,17 +1424,869 @@ interface AbstractPkgListParams {
 }
 interface AbstractPkgListResult extends AbstractPkgResult {
 }
-declare const _default$z: TaskFn<AbstractPkgListParams, AbstractPkgListResult>;
+declare const _default$2$: TaskFn<AbstractPkgListParams, AbstractPkgListResult>;
 
-interface AbstractPkgCleanParams {
-    /** Force use of specific package manager (auto-detect if not specified) */
-    packageManager?: string;
+declare const _default$2_: TaskFn<AbstractPkgCleanParams, AbstractPkgCleanResult>;
+
+interface AptBaseParams extends AbstractPkgParams {
+    /** Force use of apt package manager (always true for apt-specific tasks) */
+    packageManager?: 'apt';
+    /** Whether to install recommended packages (default: false) */
+    installRecommends?: boolean;
+    /** Whether to install suggested packages (default: false) */
+    installSuggests?: boolean;
+    /** Whether to hold packages (prevent automatic upgrades) */
+    hold?: boolean;
+    /** Whether to allow downgrades */
+    allowDowngrades?: boolean;
+    /** Whether to allow removal of essential packages */
+    allowRemoveEssential?: boolean;
+    /** Whether to allow changes to held packages */
+    allowChangeHeld?: boolean;
+}
+interface AptInstallParams extends AptBaseParams {
+    /** Package name or array of package names */
+    package: string | string[];
+    /** Whether to fix broken dependencies */
+    fixBroken?: boolean;
+    /** Whether to reinstall packages */
+    reinstall?: boolean;
+}
+interface AptInstallResult extends AbstractPkgResult {
+    /** List of installed packages with versions */
+    installed?: Array<{
+        name: string;
+        version: string;
+        architecture?: string;
+    }>;
+    /** List of packages that were already installed */
+    alreadyInstalled?: string[];
+    /** List of packages that failed to install */
+    failed?: string[];
+}
+interface AptUninstallParams extends AptBaseParams {
+    /** Package name or array of package names */
+    package: string | string[];
+    /** Whether to purge configuration files */
+    purge?: boolean;
+    /** Whether to remove dependencies that are no longer needed */
+    autoremove?: boolean;
+}
+interface AptUninstallResult extends AbstractPkgResult {
+    /** List of removed packages */
+    removed?: string[];
+    /** List of packages that were not installed */
+    notInstalled?: string[];
+    /** List of packages that failed to remove */
+    failed?: string[];
+}
+interface AptUpdateParams extends AptBaseParams {
+    /** Whether to update package lists */
+    updateLists?: boolean;
+    /** Whether to upgrade packages */
+    upgrade?: boolean;
+}
+interface AptUpdateResult extends AbstractPkgResult {
+    /** Number of packages updated */
+    packagesUpdated?: number;
+    /** List of updated packages */
+    updatedPackages?: string[];
+}
+interface AptUpgradeParams extends AptBaseParams {
+    /** Whether to perform a full upgrade (dist-upgrade) */
+    fullUpgrade?: boolean;
+    /** Whether to upgrade only security updates */
+    securityOnly?: boolean;
+}
+interface AptUpgradeResult extends AbstractPkgResult {
+    /** Number of packages upgraded */
+    packagesUpgraded?: number;
+    /** List of upgraded packages */
+    upgradedPackages?: string[];
+    /** Whether a reboot is recommended */
+    rebootRecommended?: boolean;
+}
+interface AptSearchParams extends AptBaseParams {
+    /** Search query */
+    query: string;
+    /** Whether to search in package names only */
+    namesOnly?: boolean;
+    /** Whether to search in package descriptions */
+    descriptions?: boolean;
+}
+interface AptSearchResult extends AbstractPkgResult {
+    /** Search results */
+    results?: Array<{
+        name: string;
+        version?: string;
+        description?: string;
+        installed?: boolean;
+    }>;
+}
+interface AptListParams extends AptBaseParams {
+    /** Filter by package name pattern */
+    pattern?: string;
+    /** Whether to show only installed packages */
+    installed?: boolean;
+    /** Whether to show only upgradable packages */
+    upgradable?: boolean;
+}
+interface AptListResult extends AbstractPkgResult {
+    /** List of packages */
+    packages?: Array<{
+        name: string;
+        version: string;
+        architecture?: string;
+        status?: string;
+        description?: string;
+    }>;
+}
+interface AptCleanParams extends AptBaseParams {
+    /** Whether to remove unused packages */
+    autoremove?: boolean;
+    /** Whether to clean package cache */
+    autoclean?: boolean;
+}
+interface AptCleanResult extends AbstractPkgResult {
+    /** Number of packages removed */
+    packagesRemoved?: number;
+    /** Amount of disk space freed */
+    spaceFreed?: string;
+}
+interface AptIsInstalledParams extends AptBaseParams {
+    /** Package name */
+    package: string;
 }
-interface AbstractPkgCleanResult extends AbstractPkgResult {
+interface AptIsInstalledResult extends AbstractPkgResult {
+    /** Whether the package is installed */
+    installed: boolean;
+    /** Package version if installed */
+    version?: string;
+    /** Package architecture if installed */
+    architecture?: string;
+}
+interface AptInfoParams extends AptBaseParams {
+    /** Package name */
+    package: string;
+}
+interface AptInfoResult extends AbstractPkgResult {
+    /** Package information */
+    info?: {
+        name: string;
+        version?: string;
+        architecture?: string;
+        description?: string;
+        depends?: string[];
+        recommends?: string[];
+        suggests?: string[];
+        conflicts?: string[];
+        provides?: string[];
+        replaces?: string[];
+        size?: string;
+        priority?: string;
+        section?: string;
+        maintainer?: string;
+        homepage?: string;
+    };
+    /** Whether the package is installed */
+    installed?: boolean;
+}
+interface AptAddKeyParams {
+    url: string;
+    keyring: string;
+    /** Run commands with sudo (default true) */
+    sudo?: boolean;
+}
+interface AptAddKeyResult {
+    success: boolean;
+    error?: string;
+}
+interface AptAddRepositoryParams {
+    repo: string;
+    name: string;
+    /** Run commands with sudo (default true) */
+    sudo?: boolean;
+}
+interface AptAddRepositoryResult {
+    success: boolean;
+    error?: string;
 }
-declare const _default$y: TaskFn<AbstractPkgCleanParams, AbstractPkgCleanResult>;
 
-type pkg_AbstractPkgCleanParams = AbstractPkgCleanParams;
+declare const _default$2Z: TaskFn<AptInstallParams, AptInstallResult>;
+
+declare const _default$2Y: TaskFn<AptUninstallParams, AptUninstallResult>;
+
+declare const _default$2X: TaskFn<AptUpdateParams, AptUpdateResult>;
+
+declare const _default$2W: TaskFn<AptUpgradeParams, AptUpgradeResult>;
+
+declare const _default$2V: TaskFn<AptSearchParams, AptSearchResult>;
+
+declare const _default$2U: TaskFn<AptListParams, AptListResult>;
+
+declare const _default$2T: TaskFn<AptCleanParams, AptCleanResult>;
+
+declare const _default$2S: TaskFn<AptIsInstalledParams, AptIsInstalledResult>;
+
+declare const _default$2R: TaskFn<AptInfoParams, AptInfoResult>;
+
+declare const _default$2Q: TaskFn<AptAddKeyParams, AptAddKeyResult>;
+
+declare const _default$2P: TaskFn<AptAddRepositoryParams, AptAddRepositoryResult>;
+
+type index$3_AptAddKeyParams = AptAddKeyParams;
+type index$3_AptAddKeyResult = AptAddKeyResult;
+type index$3_AptAddRepositoryParams = AptAddRepositoryParams;
+type index$3_AptAddRepositoryResult = AptAddRepositoryResult;
+type index$3_AptCleanParams = AptCleanParams;
+type index$3_AptCleanResult = AptCleanResult;
+type index$3_AptInfoParams = AptInfoParams;
+type index$3_AptInfoResult = AptInfoResult;
+type index$3_AptInstallParams = AptInstallParams;
+type index$3_AptInstallResult = AptInstallResult;
+type index$3_AptIsInstalledParams = AptIsInstalledParams;
+type index$3_AptIsInstalledResult = AptIsInstalledResult;
+type index$3_AptListParams = AptListParams;
+type index$3_AptListResult = AptListResult;
+type index$3_AptSearchParams = AptSearchParams;
+type index$3_AptSearchResult = AptSearchResult;
+type index$3_AptUninstallParams = AptUninstallParams;
+type index$3_AptUninstallResult = AptUninstallResult;
+type index$3_AptUpdateParams = AptUpdateParams;
+type index$3_AptUpdateResult = AptUpdateResult;
+type index$3_AptUpgradeParams = AptUpgradeParams;
+type index$3_AptUpgradeResult = AptUpgradeResult;
+declare namespace index$3 {
+  export { type index$3_AptAddKeyParams as AptAddKeyParams, type index$3_AptAddKeyResult as AptAddKeyResult, type index$3_AptAddRepositoryParams as AptAddRepositoryParams, type index$3_AptAddRepositoryResult as AptAddRepositoryResult, type index$3_AptCleanParams as AptCleanParams, type index$3_AptCleanResult as AptCleanResult, type index$3_AptInfoParams as AptInfoParams, type index$3_AptInfoResult as AptInfoResult, type index$3_AptInstallParams as AptInstallParams, type index$3_AptInstallResult as AptInstallResult, type index$3_AptIsInstalledParams as AptIsInstalledParams, type index$3_AptIsInstalledResult as AptIsInstalledResult, type index$3_AptListParams as AptListParams, type index$3_AptListResult as AptListResult, type index$3_AptSearchParams as AptSearchParams, type index$3_AptSearchResult as AptSearchResult, type index$3_AptUninstallParams as AptUninstallParams, type index$3_AptUninstallResult as AptUninstallResult, type index$3_AptUpdateParams as AptUpdateParams, type index$3_AptUpdateResult as AptUpdateResult, type index$3_AptUpgradeParams as AptUpgradeParams, type index$3_AptUpgradeResult as AptUpgradeResult, _default$2Q as add_key, _default$2P as add_repository, _default$2T as clean, _default$2R as info, _default$2Z as install, _default$2S as isInstalled, _default$2U as list, _default$2V as search, _default$2Y as uninstall, _default$2X as update, _default$2W as upgrade };
+}
+
+interface DnfBaseParams extends AbstractPkgParams {
+    /** Force use of dnf package manager (always true for dnf-specific tasks) */
+    packageManager?: 'dnf';
+    /** Whether to install weak dependencies (default: false) */
+    installWeakDeps?: boolean;
+    /** Whether to install recommended packages (default: false) */
+    installRecommends?: boolean;
+    /** Whether to allow downgrades */
+    allowDowngrades?: boolean;
+    /** Whether to allow erasing of protected packages */
+    allowErasing?: boolean;
+    /** Whether to skip broken packages */
+    skipBroken?: boolean;
+}
+interface DnfInstallParams extends DnfBaseParams {
+    /** Package name or array of package names */
+    package: string | string[];
+    /** Whether to install from a specific repository */
+    repo?: string;
+    /** Whether to install the best available version */
+    best?: boolean;
+}
+interface DnfInstallResult extends AbstractPkgResult {
+    /** List of installed packages with versions */
+    installed?: Array<{
+        name: string;
+        version: string;
+        architecture?: string;
+        repository?: string;
+    }>;
+    /** List of packages that were already installed */
+    alreadyInstalled?: string[];
+    /** List of packages that failed to install */
+    failed?: string[];
+}
+interface DnfUninstallParams extends DnfBaseParams {
+    /** Package name or array of package names */
+    package: string | string[];
+    /** Whether to remove dependencies that are no longer needed */
+    autoremove?: boolean;
+    /** Whether to remove all packages that depend on the specified packages */
+    removeDeps?: boolean;
+}
+interface DnfUninstallResult extends AbstractPkgResult {
+    /** List of removed packages */
+    removed?: string[];
+    /** List of packages that were not installed */
+    notInstalled?: string[];
+    /** List of packages that failed to remove */
+    failed?: string[];
+}
+interface DnfUpdateParams extends DnfBaseParams {
+    /** Whether to update package metadata */
+    updateMetadata?: boolean;
+    /** Whether to upgrade packages */
+    upgrade?: boolean;
+}
+interface DnfUpdateResult extends AbstractPkgResult {
+    /** Number of packages updated */
+    packagesUpdated?: number;
+    /** List of updated packages */
+    updatedPackages?: string[];
+}
+interface DnfUpgradeParams extends DnfBaseParams {
+    /** Whether to perform a full system upgrade */
+    fullUpgrade?: boolean;
+    /** Whether to upgrade only security updates */
+    securityOnly?: boolean;
+}
+interface DnfUpgradeResult extends AbstractPkgResult {
+    /** Number of packages upgraded */
+    packagesUpgraded?: number;
+    /** List of upgraded packages */
+    upgradedPackages?: string[];
+    /** Whether a reboot is recommended */
+    rebootRecommended?: boolean;
+}
+interface DnfSearchParams extends DnfBaseParams {
+    /** Search query */
+    query: string;
+    /** Whether to search in package names only */
+    namesOnly?: boolean;
+    /** Whether to search in package descriptions */
+    descriptions?: boolean;
+}
+interface DnfSearchResult extends AbstractPkgResult {
+    /** Search results */
+    results?: Array<{
+        name: string;
+        version?: string;
+        architecture?: string;
+        repository?: string;
+        description?: string;
+        installed?: boolean;
+    }>;
+}
+interface DnfListParams extends DnfBaseParams {
+    /** Filter by package name pattern */
+    pattern?: string;
+    /** Whether to show only installed packages */
+    installed?: boolean;
+    /** Whether to show only available packages */
+    available?: boolean;
+    /** Whether to show only upgradable packages */
+    upgradable?: boolean;
+}
+interface DnfListResult extends AbstractPkgResult {
+    /** List of packages */
+    packages?: Array<{
+        name: string;
+        version: string;
+        architecture?: string;
+        repository?: string;
+        status?: string;
+        description?: string;
+    }>;
+}
+interface DnfCleanParams extends DnfBaseParams {
+    /** Whether to clean all caches */
+    all?: boolean;
+    /** Whether to clean package cache */
+    packages?: boolean;
+    /** Whether to clean metadata cache */
+    metadata?: boolean;
+}
+interface DnfCleanResult extends AbstractPkgResult {
+    /** Number of packages removed */
+    packagesRemoved?: number;
+    /** Amount of disk space freed */
+    spaceFreed?: string;
+}
+interface DnfIsInstalledParams extends DnfBaseParams {
+    /** Package name */
+    package: string;
+}
+interface DnfIsInstalledResult extends AbstractPkgResult {
+    /** Whether the package is installed */
+    installed: boolean;
+    /** Package version if installed */
+    version?: string;
+    /** Package architecture if installed */
+    architecture?: string;
+    /** Package repository if installed */
+    repository?: string;
+}
+interface DnfInfoParams extends DnfBaseParams {
+    /** Package name */
+    package: string;
+}
+interface DnfInfoResult extends AbstractPkgResult {
+    /** Package information */
+    info?: {
+        name: string;
+        version?: string;
+        architecture?: string;
+        repository?: string;
+        description?: string;
+        depends?: string[];
+        provides?: string[];
+        conflicts?: string[];
+        obsoletes?: string[];
+        size?: string;
+        license?: string;
+        vendor?: string;
+        url?: string;
+    };
+    /** Whether the package is installed */
+    installed?: boolean;
+}
+
+declare const _default$2O: TaskFn<DnfInstallParams, DnfInstallResult>;
+
+declare const _default$2N: TaskFn<DnfUninstallParams, DnfUninstallResult>;
+
+declare const _default$2M: TaskFn<DnfUpdateParams, DnfUpdateResult>;
+
+declare const _default$2L: TaskFn<DnfUpgradeParams, DnfUpgradeResult>;
+
+declare const _default$2K: TaskFn<DnfSearchParams, DnfSearchResult>;
+
+declare const _default$2J: TaskFn<DnfListParams, DnfListResult>;
+
+declare const _default$2I: TaskFn<DnfCleanParams, DnfCleanResult>;
+
+declare const _default$2H: TaskFn<DnfIsInstalledParams, DnfIsInstalledResult>;
+
+declare const _default$2G: TaskFn<DnfInfoParams, DnfInfoResult>;
+
+type index$2_DnfCleanParams = DnfCleanParams;
+type index$2_DnfCleanResult = DnfCleanResult;
+type index$2_DnfInfoParams = DnfInfoParams;
+type index$2_DnfInfoResult = DnfInfoResult;
+type index$2_DnfInstallParams = DnfInstallParams;
+type index$2_DnfInstallResult = DnfInstallResult;
+type index$2_DnfIsInstalledParams = DnfIsInstalledParams;
+type index$2_DnfIsInstalledResult = DnfIsInstalledResult;
+type index$2_DnfListParams = DnfListParams;
+type index$2_DnfListResult = DnfListResult;
+type index$2_DnfSearchParams = DnfSearchParams;
+type index$2_DnfSearchResult = DnfSearchResult;
+type index$2_DnfUninstallParams = DnfUninstallParams;
+type index$2_DnfUninstallResult = DnfUninstallResult;
+type index$2_DnfUpdateParams = DnfUpdateParams;
+type index$2_DnfUpdateResult = DnfUpdateResult;
+type index$2_DnfUpgradeParams = DnfUpgradeParams;
+type index$2_DnfUpgradeResult = DnfUpgradeResult;
+declare namespace index$2 {
+  export { type index$2_DnfCleanParams as DnfCleanParams, type index$2_DnfCleanResult as DnfCleanResult, type index$2_DnfInfoParams as DnfInfoParams, type index$2_DnfInfoResult as DnfInfoResult, type index$2_DnfInstallParams as DnfInstallParams, type index$2_DnfInstallResult as DnfInstallResult, type index$2_DnfIsInstalledParams as DnfIsInstalledParams, type index$2_DnfIsInstalledResult as DnfIsInstalledResult, type index$2_DnfListParams as DnfListParams, type index$2_DnfListResult as DnfListResult, type index$2_DnfSearchParams as DnfSearchParams, type index$2_DnfSearchResult as DnfSearchResult, type index$2_DnfUninstallParams as DnfUninstallParams, type index$2_DnfUninstallResult as DnfUninstallResult, type index$2_DnfUpdateParams as DnfUpdateParams, type index$2_DnfUpdateResult as DnfUpdateResult, type index$2_DnfUpgradeParams as DnfUpgradeParams, type index$2_DnfUpgradeResult as DnfUpgradeResult, _default$2I as clean, _default$2G as info, _default$2O as install, _default$2H as isInstalled, _default$2J as list, _default$2K as search, _default$2N as uninstall, _default$2M as update, _default$2L as upgrade };
+}
+
+interface YumBaseParams extends AbstractPkgParams {
+    /** Force use of yum package manager (always true for yum-specific tasks) */
+    packageManager?: 'yum';
+    /** Whether to install weak dependencies (default: false) */
+    installWeakDeps?: boolean;
+    /** Whether to allow downgrades */
+    allowDowngrades?: boolean;
+    /** Whether to allow erasing of protected packages */
+    allowErasing?: boolean;
+}
+interface YumInstallParams extends YumBaseParams {
+    /** Package name or array of package names */
+    package: string | string[];
+    /** Whether to install from a specific repository */
+    repo?: string;
+}
+interface YumInstallResult extends AbstractPkgResult {
+    /** List of installed packages with versions */
+    installed?: Array<{
+        name: string;
+        version: string;
+        architecture?: string;
+        repository?: string;
+    }>;
+    /** List of packages that were already installed */
+    alreadyInstalled?: string[];
+    /** List of packages that failed to install */
+    failed?: string[];
+}
+interface YumUninstallParams extends YumBaseParams {
+    /** Package name or array of package names */
+    package: string | string[];
+    /** Whether to remove dependencies that are no longer needed */
+    autoremove?: boolean;
+}
+interface YumUninstallResult extends AbstractPkgResult {
+    /** List of removed packages */
+    removed?: string[];
+    /** List of packages that were not installed */
+    notInstalled?: string[];
+    /** List of packages that failed to remove */
+    failed?: string[];
+}
+interface YumUpdateParams extends YumBaseParams {
+    /** Whether to update package metadata */
+    updateMetadata?: boolean;
+    /** Whether to upgrade packages */
+    upgrade?: boolean;
+}
+interface YumUpdateResult extends AbstractPkgResult {
+    /** Number of packages updated */
+    packagesUpdated?: number;
+    /** List of updated packages */
+    updatedPackages?: string[];
+}
+interface YumUpgradeParams extends YumBaseParams {
+    /** Whether to perform a full system upgrade */
+    fullUpgrade?: boolean;
+    /** Whether to upgrade only security updates */
+    securityOnly?: boolean;
+}
+interface YumUpgradeResult extends AbstractPkgResult {
+    /** Number of packages upgraded */
+    packagesUpgraded?: number;
+    /** List of upgraded packages */
+    upgradedPackages?: string[];
+    /** Whether a reboot is recommended */
+    rebootRecommended?: boolean;
+}
+interface YumSearchParams extends YumBaseParams {
+    /** Search query */
+    query: string;
+    /** Whether to search in package names only */
+    namesOnly?: boolean;
+    /** Whether to search in package descriptions */
+    descriptions?: boolean;
+}
+interface YumSearchResult extends AbstractPkgResult {
+    /** Search results */
+    results?: Array<{
+        name: string;
+        version?: string;
+        architecture?: string;
+        repository?: string;
+        description?: string;
+        installed?: boolean;
+    }>;
+}
+interface YumListParams extends YumBaseParams {
+    /** Filter by package name pattern */
+    pattern?: string;
+    /** Whether to show only installed packages */
+    installed?: boolean;
+    /** Whether to show only available packages */
+    available?: boolean;
+    /** Whether to show only upgradable packages */
+    upgradable?: boolean;
+}
+interface YumListResult extends AbstractPkgResult {
+    /** List of packages */
+    packages?: Array<{
+        name: string;
+        version: string;
+        architecture?: string;
+        repository?: string;
+        status?: string;
+        description?: string;
+    }>;
+}
+interface YumCleanParams extends YumBaseParams {
+    /** Whether to clean all caches */
+    all?: boolean;
+    /** Whether to clean package cache */
+    packages?: boolean;
+    /** Whether to clean metadata cache */
+    metadata?: boolean;
+}
+interface YumCleanResult extends AbstractPkgResult {
+    /** Number of packages removed */
+    packagesRemoved?: number;
+    /** Amount of disk space freed */
+    spaceFreed?: string;
+}
+interface YumIsInstalledParams extends YumBaseParams {
+    /** Package name */
+    package: string;
+}
+interface YumIsInstalledResult extends AbstractPkgResult {
+    /** Whether the package is installed */
+    installed: boolean;
+    /** Package version if installed */
+    version?: string;
+    /** Package architecture if installed */
+    architecture?: string;
+    /** Package repository if installed */
+    repository?: string;
+}
+interface YumInfoParams extends YumBaseParams {
+    /** Package name */
+    package: string;
+}
+interface YumInfoResult extends AbstractPkgResult {
+    /** Package information */
+    info?: {
+        name: string;
+        version?: string;
+        architecture?: string;
+        repository?: string;
+        description?: string;
+        depends?: string[];
+        provides?: string[];
+        conflicts?: string[];
+        obsoletes?: string[];
+        size?: string;
+        license?: string;
+        vendor?: string;
+        url?: string;
+    };
+    /** Whether the package is installed */
+    installed?: boolean;
+}
+
+declare const _default$2F: TaskFn<YumInstallParams, YumInstallResult>;
+
+declare const _default$2E: TaskFn<YumUninstallParams, YumUninstallResult>;
+
+declare const _default$2D: TaskFn<YumUpdateParams, YumUpdateResult>;
+
+declare const _default$2C: TaskFn<YumUpgradeParams, YumUpgradeResult>;
+
+declare const _default$2B: TaskFn<YumSearchParams, YumSearchResult>;
+
+declare const _default$2A: TaskFn<{}, {
+    success: boolean;
+    packages: {
+        name: string;
+        version: string;
+        arch: string;
+        repository: string;
+    }[];
+    error?: string;
+}>;
+
+declare const _default$2z: TaskFn<YumCleanParams, YumCleanResult>;
+
+declare const _default$2y: TaskFn<YumIsInstalledParams, YumIsInstalledResult>;
+
+declare const _default$2x: TaskFn<YumInfoParams, YumInfoResult>;
+
+type index$1_YumCleanParams = YumCleanParams;
+type index$1_YumCleanResult = YumCleanResult;
+type index$1_YumInfoParams = YumInfoParams;
+type index$1_YumInfoResult = YumInfoResult;
+type index$1_YumInstallParams = YumInstallParams;
+type index$1_YumInstallResult = YumInstallResult;
+type index$1_YumIsInstalledParams = YumIsInstalledParams;
+type index$1_YumIsInstalledResult = YumIsInstalledResult;
+type index$1_YumListParams = YumListParams;
+type index$1_YumListResult = YumListResult;
+type index$1_YumSearchParams = YumSearchParams;
+type index$1_YumSearchResult = YumSearchResult;
+type index$1_YumUninstallParams = YumUninstallParams;
+type index$1_YumUninstallResult = YumUninstallResult;
+type index$1_YumUpdateParams = YumUpdateParams;
+type index$1_YumUpdateResult = YumUpdateResult;
+type index$1_YumUpgradeParams = YumUpgradeParams;
+type index$1_YumUpgradeResult = YumUpgradeResult;
+declare namespace index$1 {
+  export { type index$1_YumCleanParams as YumCleanParams, type index$1_YumCleanResult as YumCleanResult, type index$1_YumInfoParams as YumInfoParams, type index$1_YumInfoResult as YumInfoResult, type index$1_YumInstallParams as YumInstallParams, type index$1_YumInstallResult as YumInstallResult, type index$1_YumIsInstalledParams as YumIsInstalledParams, type index$1_YumIsInstalledResult as YumIsInstalledResult, type index$1_YumListParams as YumListParams, type index$1_YumListResult as YumListResult, type index$1_YumSearchParams as YumSearchParams, type index$1_YumSearchResult as YumSearchResult, type index$1_YumUninstallParams as YumUninstallParams, type index$1_YumUninstallResult as YumUninstallResult, type index$1_YumUpdateParams as YumUpdateParams, type index$1_YumUpdateResult as YumUpdateResult, type index$1_YumUpgradeParams as YumUpgradeParams, type index$1_YumUpgradeResult as YumUpgradeResult, _default$2z as clean, _default$2x as info, _default$2F as install, _default$2y as isInstalled, _default$2A as list, _default$2B as search, _default$2E as uninstall, _default$2D as update, _default$2C as upgrade };
+}
+
+interface PacmanBaseParams extends AbstractPkgParams {
+    /** Force use of pacman package manager (always true for pacman-specific tasks) */
+    packageManager?: 'pacman';
+    /** Whether to install dependencies */
+    installDeps?: boolean;
+    /** Whether to install as dependencies */
+    asDeps?: boolean;
+    /** Whether to install as explicit packages */
+    asExplicit?: boolean;
+}
+interface PacmanInstallParams extends PacmanBaseParams {
+    /** Package name or array of package names */
+    package: string | string[];
+    /** Whether to install from a specific repository */
+    repo?: string;
+    /** Whether to install the best available version */
+    best?: boolean;
+}
+interface PacmanInstallResult extends AbstractPkgResult {
+    /** List of installed packages with versions */
+    installed?: Array<{
+        name: string;
+        version: string;
+        architecture?: string;
+        repository?: string;
+    }>;
+    /** List of packages that were already installed */
+    alreadyInstalled?: string[];
+    /** List of packages that failed to install */
+    failed?: string[];
+}
+interface PacmanUninstallParams extends PacmanBaseParams {
+    /** Package name or array of package names */
+    package: string | string[];
+    /** Whether to remove dependencies that are no longer needed */
+    cascade?: boolean;
+    /** Whether to remove all packages that depend on the specified packages */
+    recursive?: boolean;
+}
+interface PacmanUninstallResult extends AbstractPkgResult {
+    /** List of removed packages */
+    removed?: string[];
+    /** List of packages that were not installed */
+    notInstalled?: string[];
+    /** List of packages that failed to remove */
+    failed?: string[];
+}
+interface PacmanUpdateParams extends PacmanBaseParams {
+    /** Whether to update package metadata */
+    updateMetadata?: boolean;
+    /** Whether to upgrade packages */
+    upgrade?: boolean;
+}
+interface PacmanUpdateResult extends AbstractPkgResult {
+    /** Number of packages updated */
+    packagesUpdated?: number;
+    /** List of updated packages */
+    updatedPackages?: string[];
+}
+interface PacmanUpgradeParams extends PacmanBaseParams {
+    /** Whether to perform a full system upgrade */
+    fullUpgrade?: boolean;
+    /** Whether to upgrade only security updates */
+    securityOnly?: boolean;
+}
+interface PacmanUpgradeResult extends AbstractPkgResult {
+    /** Number of packages upgraded */
+    packagesUpgraded?: number;
+    /** List of upgraded packages */
+    upgradedPackages?: string[];
+    /** Whether a reboot is recommended */
+    rebootRecommended?: boolean;
+}
+interface PacmanSearchParams extends PacmanBaseParams {
+    /** Search query */
+    query: string;
+    /** Whether to search in package names only */
+    namesOnly?: boolean;
+    /** Whether to search in package descriptions */
+    descriptions?: boolean;
+}
+interface PacmanSearchResult extends AbstractPkgResult {
+    /** Search results */
+    results?: Array<{
+        name: string;
+        version?: string;
+        architecture?: string;
+        repository?: string;
+        description?: string;
+        installed?: boolean;
+    }>;
+}
+interface PacmanListParams extends PacmanBaseParams {
+    /** Filter by package name pattern */
+    pattern?: string;
+    /** Whether to show only installed packages */
+    installed?: boolean;
+    /** Whether to show only available packages */
+    available?: boolean;
+    /** Whether to show only upgradable packages */
+    upgradable?: boolean;
+}
+interface PacmanListResult extends AbstractPkgResult {
+    /** List of packages */
+    packages?: Array<{
+        name: string;
+        version: string;
+        architecture?: string;
+        repository?: string;
+        status?: string;
+        description?: string;
+    }>;
+}
+interface PacmanCleanParams extends PacmanBaseParams {
+    /** Whether to clean all caches */
+    all?: boolean;
+    /** Whether to clean package cache */
+    packages?: boolean;
+    /** Whether to clean metadata cache */
+    metadata?: boolean;
+}
+interface PacmanCleanResult extends AbstractPkgResult {
+    /** Number of packages removed */
+    packagesRemoved?: number;
+    /** Amount of disk space freed */
+    spaceFreed?: string;
+}
+interface PacmanIsInstalledParams extends PacmanBaseParams {
+    /** Package name */
+    package: string;
+}
+interface PacmanIsInstalledResult extends AbstractPkgResult {
+    /** Whether the package is installed */
+    installed: boolean;
+    /** Package version if installed */
+    version?: string;
+    /** Package architecture if installed */
+    architecture?: string;
+    /** Package repository if installed */
+    repository?: string;
+}
+interface PacmanInfoParams extends PacmanBaseParams {
+    /** Package name */
+    package: string;
+}
+interface PacmanInfoResult extends AbstractPkgResult {
+    /** Whether the package is installed */
+    installed: boolean;
+    /** Package information */
+    info?: {
+        name: string;
+        version?: string;
+        architecture?: string;
+        repository?: string;
+        description?: string;
+        depends?: string[];
+        provides?: string[];
+        conflicts?: string[];
+        replaces?: string[];
+        size?: string;
+        license?: string;
+        url?: string;
+    };
+}
+
+declare const _default$2w: TaskFn<PacmanInstallParams, PacmanInstallResult>;
+
+declare const _default$2v: TaskFn<PacmanUninstallParams, PacmanUninstallResult>;
+
+declare const _default$2u: TaskFn<PacmanUpdateParams, PacmanUpdateResult>;
+
+declare const _default$2t: TaskFn<PacmanUpgradeParams, PacmanUpgradeResult>;
+
+declare const _default$2s: TaskFn<PacmanSearchParams, PacmanSearchResult>;
+
+declare const _default$2r: TaskFn<PacmanListParams, PacmanListResult>;
+
+declare const _default$2q: TaskFn<PacmanCleanParams, PacmanCleanResult>;
+
+declare const _default$2p: TaskFn<PacmanIsInstalledParams, PacmanIsInstalledResult>;
+
+declare const _default$2o: TaskFn<PacmanInfoParams, PacmanInfoResult>;
+
+type index_PacmanCleanParams = PacmanCleanParams;
+type index_PacmanCleanResult = PacmanCleanResult;
+type index_PacmanInfoParams = PacmanInfoParams;
+type index_PacmanInfoResult = PacmanInfoResult;
+type index_PacmanInstallParams = PacmanInstallParams;
+type index_PacmanInstallResult = PacmanInstallResult;
+type index_PacmanIsInstalledParams = PacmanIsInstalledParams;
+type index_PacmanIsInstalledResult = PacmanIsInstalledResult;
+type index_PacmanListParams = PacmanListParams;
+type index_PacmanListResult = PacmanListResult;
+type index_PacmanSearchParams = PacmanSearchParams;
+type index_PacmanSearchResult = PacmanSearchResult;
+type index_PacmanUninstallParams = PacmanUninstallParams;
+type index_PacmanUninstallResult = PacmanUninstallResult;
+type index_PacmanUpdateParams = PacmanUpdateParams;
+type index_PacmanUpdateResult = PacmanUpdateResult;
+type index_PacmanUpgradeParams = PacmanUpgradeParams;
+type index_PacmanUpgradeResult = PacmanUpgradeResult;
+declare namespace index {
+  export { type index_PacmanCleanParams as PacmanCleanParams, type index_PacmanCleanResult as PacmanCleanResult, type index_PacmanInfoParams as PacmanInfoParams, type index_PacmanInfoResult as PacmanInfoResult, type index_PacmanInstallParams as PacmanInstallParams, type index_PacmanInstallResult as PacmanInstallResult, type index_PacmanIsInstalledParams as PacmanIsInstalledParams, type index_PacmanIsInstalledResult as PacmanIsInstalledResult, type index_PacmanListParams as PacmanListParams, type index_PacmanListResult as PacmanListResult, type index_PacmanSearchParams as PacmanSearchParams, type index_PacmanSearchResult as PacmanSearchResult, type index_PacmanUninstallParams as PacmanUninstallParams, type index_PacmanUninstallResult as PacmanUninstallResult, type index_PacmanUpdateParams as PacmanUpdateParams, type index_PacmanUpdateResult as PacmanUpdateResult, type index_PacmanUpgradeParams as PacmanUpgradeParams, type index_PacmanUpgradeResult as PacmanUpgradeResult, _default$2q as clean, _default$2o as info, _default$2w as install, _default$2p as isInstalled, _default$2r as list, _default$2s as search, _default$2v as uninstall, _default$2u as update, _default$2t as upgrade };
+}
+
+type pkg_AbstractPkgCleanParams = AbstractPkgCleanParams;
 type pkg_AbstractPkgCleanResult = AbstractPkgCleanResult;
 type pkg_AbstractPkgInstallParams = AbstractPkgInstallParams;
 type pkg_AbstractPkgInstallResult = AbstractPkgInstallResult;
@@ -1315,7 +2313,7 @@ type pkg_PkgRemoveResult = PkgRemoveResult;
 type pkg_PkgUpdateParams = PkgUpdateParams;
 type pkg_PkgUpdateResult = PkgUpdateResult;
 declare namespace pkg {
-  export { type pkg_AbstractPkgCleanParams as AbstractPkgCleanParams, type pkg_AbstractPkgCleanResult as AbstractPkgCleanResult, type pkg_AbstractPkgInstallParams as AbstractPkgInstallParams, type pkg_AbstractPkgInstallResult as AbstractPkgInstallResult, type pkg_AbstractPkgListParams as AbstractPkgListParams, type pkg_AbstractPkgListResult as AbstractPkgListResult, type pkg_AbstractPkgParams as AbstractPkgParams, type pkg_AbstractPkgResult as AbstractPkgResult, type pkg_AbstractPkgSearchParams as AbstractPkgSearchParams, type pkg_AbstractPkgSearchResult as AbstractPkgSearchResult, type pkg_AbstractPkgUninstallParams as AbstractPkgUninstallParams, type pkg_AbstractPkgUninstallResult as AbstractPkgUninstallResult, type pkg_AbstractPkgUpdateParams as AbstractPkgUpdateParams, type pkg_AbstractPkgUpdateResult as AbstractPkgUpdateResult, type pkg_AbstractPkgUpgradeParams as AbstractPkgUpgradeParams, type pkg_AbstractPkgUpgradeResult as AbstractPkgUpgradeResult, type pkg_PkgInfoParams as PkgInfoParams, type pkg_PkgInfoResult as PkgInfoResult, type pkg_PkgInstallParams as PkgInstallParams, type pkg_PkgInstallResult as PkgInstallResult, type pkg_PkgIsInstalledParams as PkgIsInstalledParams, type pkg_PkgIsInstalledResult as PkgIsInstalledResult, type pkg_PkgRemoveParams as PkgRemoveParams, type pkg_PkgRemoveResult as PkgRemoveResult, type pkg_PkgUpdateParams as PkgUpdateParams, type pkg_PkgUpdateResult as PkgUpdateResult, _default$y as abstractClean, _default$A as abstractSearch, _default$D as abstractUninstall, _default$C as abstractUpdate, _default$B as abstractUpgrade, _default$G as info, _default$J as install, _default$E as installOrig, _default$F as isInstalled, _default$z as list, _default$I as remove, _default$H as update };
+  export { type pkg_AbstractPkgCleanParams as AbstractPkgCleanParams, type pkg_AbstractPkgCleanResult as AbstractPkgCleanResult, type pkg_AbstractPkgInstallParams as AbstractPkgInstallParams, type pkg_AbstractPkgInstallResult as AbstractPkgInstallResult, type pkg_AbstractPkgListParams as AbstractPkgListParams, type pkg_AbstractPkgListResult as AbstractPkgListResult, type pkg_AbstractPkgParams as AbstractPkgParams, type pkg_AbstractPkgResult as AbstractPkgResult, type pkg_AbstractPkgSearchParams as AbstractPkgSearchParams, type pkg_AbstractPkgSearchResult as AbstractPkgSearchResult, type pkg_AbstractPkgUninstallParams as AbstractPkgUninstallParams, type pkg_AbstractPkgUninstallResult as AbstractPkgUninstallResult, type pkg_AbstractPkgUpdateParams as AbstractPkgUpdateParams, type pkg_AbstractPkgUpdateResult as AbstractPkgUpdateResult, type pkg_AbstractPkgUpgradeParams as AbstractPkgUpgradeParams, type pkg_AbstractPkgUpgradeResult as AbstractPkgUpgradeResult, type pkg_PkgInfoParams as PkgInfoParams, type pkg_PkgInfoResult as PkgInfoResult, type pkg_PkgInstallParams as PkgInstallParams, type pkg_PkgInstallResult as PkgInstallResult, type pkg_PkgIsInstalledParams as PkgIsInstalledParams, type pkg_PkgIsInstalledResult as PkgIsInstalledResult, type pkg_PkgRemoveParams as PkgRemoveParams, type pkg_PkgRemoveResult as PkgRemoveResult, type pkg_PkgUpdateParams as PkgUpdateParams, type pkg_PkgUpdateResult as PkgUpdateResult, index$3 as apt, _default$2_ as clean, index$2 as dnf, _default$35 as info, _default$38 as install, install as installCp, _default$34 as isInstalled, _default$2$ as list, index as pacman, _default$37 as remove, _default$33 as removeCp, _default$30 as search, _default$36 as update, _default$32 as updateCp, _default$31 as upgrade, index$1 as yum };
 }
 
 interface K3supInstallParams {
@@ -1353,12 +2351,54 @@ interface K3supInstallResult {
     /** The command that would be run if --print-command was used */
     executedCommand?: string;
 }
-declare const _default$x: TaskFn<K3supInstallParams, K3supInstallResult>;
+declare const _default$2n: TaskFn<K3supInstallParams, K3supInstallResult>;
 
 type k3s_K3supInstallParams = K3supInstallParams;
 type k3s_K3supInstallResult = K3supInstallResult;
 declare namespace k3s {
-  export { type k3s_K3supInstallParams as K3supInstallParams, type k3s_K3supInstallResult as K3supInstallResult, _default$x as k3supInstall };
+  export { type k3s_K3supInstallParams as K3supInstallParams, type k3s_K3supInstallResult as K3supInstallResult, _default$2n as k3supInstall };
+}
+
+interface DockerInstallParams {
+    users?: string[];
+    install_compose_plugin?: boolean;
+    install_compose_standalone?: boolean;
+    compose_standalone_version?: string;
+    compose_standalone_path?: string;
+}
+interface DockerInstallResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$2m: TaskFn<DockerInstallParams, DockerInstallResult>;
+
+interface AddUsersParams {
+    users: string[];
+}
+interface AddUsersResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$2l: TaskFn<AddUsersParams, AddUsersResult>;
+
+interface InstallComposeParams {
+    version?: string;
+    path?: string;
+}
+interface InstallComposeResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$2k: TaskFn<InstallComposeParams, InstallComposeResult>;
+
+type docker_AddUsersParams = AddUsersParams;
+type docker_AddUsersResult = AddUsersResult;
+type docker_DockerInstallParams = DockerInstallParams;
+type docker_DockerInstallResult = DockerInstallResult;
+type docker_InstallComposeParams = InstallComposeParams;
+type docker_InstallComposeResult = InstallComposeResult;
+declare namespace docker {
+  export { type docker_AddUsersParams as AddUsersParams, type docker_AddUsersResult as AddUsersResult, type docker_DockerInstallParams as DockerInstallParams, type docker_DockerInstallResult as DockerInstallResult, type docker_InstallComposeParams as InstallComposeParams, type docker_InstallComposeResult as InstallComposeResult, _default$2l as addUsers, _default$2m as install, _default$2k as installCompose };
 }
 
 interface CopyIdParams {
@@ -1370,10 +2410,10 @@ interface CopyIdResult {
     success: boolean;
     changed: boolean;
 }
-declare const _default$w: TaskFn<CopyIdParams, CopyIdResult>;
+declare const _default$2j: TaskFn<CopyIdParams, CopyIdResult>;
 
 declare namespace ssh {
-  export { _default$w as copy_id };
+  export { _default$2j as copy_id };
 }
 
 interface SudoersCheckParams {
@@ -1381,8 +2421,9 @@ interface SudoersCheckParams {
 }
 interface SudoersCheckResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$v: TaskFn<SudoersCheckParams, SudoersCheckResult>;
+declare const _default$2i: TaskFn<SudoersCheckParams, SudoersCheckResult>;
 
 interface GrantNopasswdParams {
     /** The username to grant passwordless sudo privileges. */
@@ -1397,11 +2438,383 @@ interface GrantNopasswdResult {
     changed: boolean;
     /** The path to the created sudoers file. */
     filePath: string;
+    /** Error message if failed. */
+    error?: string;
 }
-declare const _default$u: TaskFn<GrantNopasswdParams, GrantNopasswdResult>;
+declare const _default$2h: TaskFn<GrantNopasswdParams, GrantNopasswdResult>;
 
 declare namespace sudoers {
-  export { _default$v as check, _default$u as grantNopasswd };
+  export { _default$2i as check, _default$2h as grantNopasswd };
+}
+
+interface ProcessListParams {
+    user?: string;
+    command?: string;
+    limit?: number;
+    sort?: 'cpu' | 'mem' | 'pid' | 'time';
+    reverse?: boolean;
+}
+interface ProcessInfo$2 {
+    pid: number;
+    ppid: number;
+    user: string;
+    command: string;
+    stat: string;
+    start: string;
+    time: string;
+    cpu: number;
+    mem: number;
+    vsz: number;
+    rss: number;
+    tty: string;
+}
+interface ProcessListResult {
+    success: boolean;
+    processes?: ProcessInfo$2[];
+    total?: number;
+    error?: string;
+}
+declare const _default$2g: TaskFn<ProcessListParams, ProcessListResult>;
+
+interface ProcessSearchParams {
+    /** Search by process name/command (supports regex) */
+    name?: string;
+    /** Search by user running the process */
+    user?: string;
+    /** Search by process ID */
+    pid?: number;
+    /** Search by parent process ID */
+    ppid?: number;
+    /** Search by command line arguments */
+    args?: string;
+    /** Search by process state */
+    state?: string;
+    /** Use regex matching for name/args (default: false) */
+    regex?: boolean;
+    /** Case insensitive search (default: false) */
+    ignoreCase?: boolean;
+    /** Maximum number of results to return (default: unlimited) */
+    limit?: number;
+}
+interface ProcessSearchResult {
+    /** Array of matching processes */
+    processes: ProcessInfo$1[];
+    /** Total number of matches found */
+    total: number;
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Error message if operation failed */
+    error?: string;
+}
+interface ProcessInfo$1 {
+    /** Process ID */
+    pid: number;
+    /** Parent Process ID */
+    ppid: number;
+    /** User running the process */
+    user: string;
+    /** CPU usage percentage */
+    cpu: number;
+    /** Memory usage percentage */
+    mem: number;
+    /** Virtual memory size in KB */
+    vsz: number;
+    /** Resident set size in KB */
+    rss: number;
+    /** Terminal associated with the process */
+    tty: string;
+    /** Process state */
+    stat: string;
+    /** Start time */
+    start: string;
+    /** Time the process has been running */
+    time: string;
+    /** Command name */
+    command: string;
+    /** Full command line */
+    fullCommand: string;
+}
+declare const _default$2f: TaskFn<ProcessSearchParams, ProcessSearchResult>;
+
+interface ProcessKillParams {
+    pid?: number | number[];
+    user?: string;
+    command?: string;
+    signal?: string;
+    force?: boolean;
+    sudo?: boolean;
+}
+interface ProcessKillResult {
+    success: boolean;
+    killed?: number;
+    total?: number;
+    error?: string;
+}
+declare const _default$2e: TaskFn<ProcessKillParams, ProcessKillResult>;
+
+interface ProcessSignalParams {
+    pid: number;
+    signal?: string;
+    sudo?: boolean;
+}
+interface ProcessSignalResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$2d: TaskFn<ProcessSignalParams, ProcessSignalResult>;
+
+interface ProcessInfoParams {
+    pid: number;
+}
+interface ProcessInfo {
+    pid: number;
+    ppid: number;
+    user: string;
+    command: string;
+    stat: string;
+    start: string;
+    time: string;
+    cpu: number;
+    mem: number;
+    vsz: number;
+    rss: number;
+    tty: string;
+    cwd?: string;
+    environ?: Record<string, string>;
+}
+interface ProcessInfoResult {
+    success: boolean;
+    process?: ProcessInfo;
+    error?: string;
+}
+declare const _default$2c: TaskFn<ProcessInfoParams, ProcessInfoResult>;
+
+interface ProcessTopParams {
+    /** Number of processes to show (default: 10) */
+    limit?: number;
+    /** Sort by field (default: 'cpu') */
+    sort?: 'cpu' | 'mem' | 'pid' | 'time' | 'command';
+    /** Show processes for specific user (default: all users) */
+    user?: string;
+    /** Refresh interval in seconds (default: 1) */
+    interval?: number;
+    /** Number of iterations (default: 1) */
+    iterations?: number;
+    /** Include system load information (default: true) */
+    includeLoad?: boolean;
+    /** Include memory summary (default: true) */
+    includeMemory?: boolean;
+}
+interface ProcessTopResult {
+    /** System load information */
+    load?: LoadInfo;
+    /** Memory summary */
+    memory?: MemorySummary;
+    /** Top processes */
+    processes: TopProcessInfo[];
+    /** Total number of processes shown */
+    total: number;
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Timestamp of the snapshot */
+    timestamp: string;
+}
+interface LoadInfo {
+    /** 1-minute load average */
+    load1: number;
+    /** 5-minute load average */
+    load5: number;
+    /** 15-minute load average */
+    load15: number;
+    /** Number of running processes */
+    running: number;
+    /** Total number of processes */
+    total: number;
+    /** Last PID */
+    lastPid: number;
+}
+interface MemorySummary {
+    /** Total physical memory in KB */
+    total: number;
+    /** Used memory in KB */
+    used: number;
+    /** Free memory in KB */
+    free: number;
+    /** Shared memory in KB */
+    shared: number;
+    /** Buffer memory in KB */
+    buffers: number;
+    /** Cache memory in KB */
+    cached: number;
+    /** Available memory in KB */
+    available: number;
+}
+interface TopProcessInfo {
+    /** Process ID */
+    pid: number;
+    /** User running the process */
+    user: string;
+    /** Priority */
+    priority: number;
+    /** Nice value */
+    nice: number;
+    /** Virtual memory size in KB */
+    vsz: number;
+    /** Resident set size in KB */
+    rss: number;
+    /** Process state */
+    stat: string;
+    /** CPU usage percentage */
+    cpu: number;
+    /** Memory usage percentage */
+    mem: number;
+    /** Time the process has been running */
+    time: string;
+    /** Command name */
+    command: string;
+}
+declare const _default$2b: TaskFn<ProcessTopParams, ProcessTopResult>;
+
+interface ProcessStatsParams {
+    /** Include per-user statistics (default: true) */
+    includeUsers?: boolean;
+    /** Include per-state statistics (default: true) */
+    includeStates?: boolean;
+    /** Include per-command statistics (default: false) */
+    includeCommands?: boolean;
+    /** Limit number of top commands to show (default: 10) */
+    commandLimit?: number;
+}
+interface ProcessStatsResult {
+    /** Overall process statistics */
+    overall: OverallStats;
+    /** Per-user statistics */
+    users?: UserStats[];
+    /** Per-state statistics */
+    states?: StateStats[];
+    /** Per-command statistics */
+    commands?: CommandStats[];
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Timestamp of the snapshot */
+    timestamp: string;
+}
+interface OverallStats {
+    /** Total number of processes */
+    total: number;
+    /** Number of running processes */
+    running: number;
+    /** Number of sleeping processes */
+    sleeping: number;
+    /** Number of stopped processes */
+    stopped: number;
+    /** Number of zombie processes */
+    zombie: number;
+    /** Number of uninterruptible processes */
+    uninterruptible: number;
+    /** Total CPU usage percentage */
+    totalCpu: number;
+    /** Total memory usage percentage */
+    totalMem: number;
+    /** Average CPU usage per process */
+    avgCpu: number;
+    /** Average memory usage per process */
+    avgMem: number;
+}
+interface UserStats {
+    /** Username */
+    user: string;
+    /** Number of processes */
+    count: number;
+    /** Total CPU usage percentage */
+    cpu: number;
+    /** Total memory usage percentage */
+    mem: number;
+    /** Total virtual memory in KB */
+    vsz: number;
+    /** Total resident memory in KB */
+    rss: number;
+}
+interface StateStats {
+    /** Process state */
+    state: string;
+    /** Number of processes in this state */
+    count: number;
+    /** Percentage of total processes */
+    percentage: number;
+}
+interface CommandStats {
+    /** Command name */
+    command: string;
+    /** Number of processes */
+    count: number;
+    /** Total CPU usage percentage */
+    cpu: number;
+    /** Total memory usage percentage */
+    mem: number;
+    /** Total virtual memory in KB */
+    vsz: number;
+    /** Total resident memory in KB */
+    rss: number;
+}
+declare const _default$2a: TaskFn<ProcessStatsParams, ProcessStatsResult>;
+
+interface ProcessChildrenParams {
+    /** Parent process ID */
+    pid: number;
+    /** Include grandchildren (recursive) */
+    recursive?: boolean;
+    /** Maximum depth for recursive search (default: unlimited) */
+    maxDepth?: number;
+}
+interface ProcessChildrenResult {
+    /** Array of child process information */
+    children: ChildProcessInfo[];
+    /** Total number of children found */
+    total: number;
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Error message if operation failed */
+    error?: string;
+}
+interface ChildProcessInfo {
+    /** Process ID */
+    pid: number;
+    /** Parent Process ID */
+    ppid: number;
+    /** User running the process */
+    user: string;
+    /** Command name */
+    command: string;
+    /** Process state */
+    stat: string;
+    /** Start time */
+    start: string;
+    /** Time the process has been running */
+    time: string;
+    /** Depth level (0 = direct child, 1 = grandchild, etc.) */
+    depth: number;
+}
+declare const _default$29: TaskFn<ProcessChildrenParams, ProcessChildrenResult>;
+
+type process_ProcessChildrenParams = ProcessChildrenParams;
+type process_ProcessChildrenResult = ProcessChildrenResult;
+type process_ProcessInfoParams = ProcessInfoParams;
+type process_ProcessInfoResult = ProcessInfoResult;
+type process_ProcessKillParams = ProcessKillParams;
+type process_ProcessKillResult = ProcessKillResult;
+type process_ProcessListParams = ProcessListParams;
+type process_ProcessListResult = ProcessListResult;
+type process_ProcessSearchParams = ProcessSearchParams;
+type process_ProcessSearchResult = ProcessSearchResult;
+type process_ProcessSignalParams = ProcessSignalParams;
+type process_ProcessSignalResult = ProcessSignalResult;
+type process_ProcessStatsParams = ProcessStatsParams;
+type process_ProcessStatsResult = ProcessStatsResult;
+type process_ProcessTopParams = ProcessTopParams;
+type process_ProcessTopResult = ProcessTopResult;
+declare namespace process {
+  export { type process_ProcessChildrenParams as ProcessChildrenParams, type process_ProcessChildrenResult as ProcessChildrenResult, type process_ProcessInfoParams as ProcessInfoParams, type process_ProcessInfoResult as ProcessInfoResult, type process_ProcessKillParams as ProcessKillParams, type process_ProcessKillResult as ProcessKillResult, type process_ProcessListParams as ProcessListParams, type process_ProcessListResult as ProcessListResult, type process_ProcessSearchParams as ProcessSearchParams, type process_ProcessSearchResult as ProcessSearchResult, type process_ProcessSignalParams as ProcessSignalParams, type process_ProcessSignalResult as ProcessSignalResult, type process_ProcessStatsParams as ProcessStatsParams, type process_ProcessStatsResult as ProcessStatsResult, type process_ProcessTopParams as ProcessTopParams, type process_ProcessTopResult as ProcessTopResult, _default$29 as children, _default$2c as info, _default$2e as kill, _default$2g as list, _default$2f as search, _default$2d as signal, _default$2a as stats, _default$2b as top };
 }
 
 interface RebootParams {
@@ -1424,7 +2837,7 @@ interface RebootResult {
     error?: string;
     status: string;
 }
-declare const _default$t: TaskFn<RebootParams, RebootResult>;
+declare const _default$28: TaskFn<RebootParams, RebootResult>;
 
 interface ShutdownParams {
     /**
@@ -1446,7 +2859,7 @@ interface ShutdownResult {
     error?: string;
     status: string;
 }
-declare const _default$s: TaskFn<ShutdownParams, ShutdownResult>;
+declare const _default$27: TaskFn<ShutdownParams, ShutdownResult>;
 
 interface RebootNeededParams {
 }
@@ -1455,7 +2868,7 @@ interface RebootNeededResult {
     success: boolean;
     error?: string;
 }
-declare const _default$r: TaskFn<RebootNeededParams, RebootNeededResult>;
+declare const _default$26: TaskFn<RebootNeededParams, RebootNeededResult>;
 
 interface RebootIfNeededParams {
     delay?: number;
@@ -1466,7 +2879,7 @@ interface RebootIfNeededResult {
     success: boolean;
     error?: string;
 }
-declare const _default$q: TaskFn<RebootIfNeededParams, RebootIfNeededResult>;
+declare const _default$25: TaskFn<RebootIfNeededParams, RebootIfNeededResult>;
 
 type system_RebootIfNeededParams = RebootIfNeededParams;
 type system_RebootIfNeededResult = RebootIfNeededResult;
@@ -1477,7 +2890,7 @@ type system_RebootResult = RebootResult;
 type system_ShutdownParams = ShutdownParams;
 type system_ShutdownResult = ShutdownResult;
 declare namespace system {
-  export { type system_RebootIfNeededParams as RebootIfNeededParams, type system_RebootIfNeededResult as RebootIfNeededResult, type system_RebootNeededParams as RebootNeededParams, type system_RebootNeededResult as RebootNeededResult, type system_RebootParams as RebootParams, type system_RebootResult as RebootResult, type system_ShutdownParams as ShutdownParams, type system_ShutdownResult as ShutdownResult, _default$t as reboot, _default$q as rebootIfNeeded, _default$r as rebootNeeded, _default$s as shutdown };
+  export { type system_RebootIfNeededParams as RebootIfNeededParams, type system_RebootIfNeededResult as RebootIfNeededResult, type system_RebootNeededParams as RebootNeededParams, type system_RebootNeededResult as RebootNeededResult, type system_RebootParams as RebootParams, type system_RebootResult as RebootResult, type system_ShutdownParams as ShutdownParams, type system_ShutdownResult as ShutdownResult, _default$28 as reboot, _default$25 as rebootIfNeeded, _default$26 as rebootNeeded, _default$27 as shutdown };
 }
 
 interface DisableServiceParams {
@@ -1486,8 +2899,9 @@ interface DisableServiceParams {
 }
 interface DisableServiceResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$p: TaskFn<DisableServiceParams, DisableServiceResult>;
+declare const _default$24: TaskFn<DisableServiceParams, DisableServiceResult>;
 
 interface SystemdEnableParams {
     service: string;
@@ -1495,8 +2909,9 @@ interface SystemdEnableParams {
 }
 interface SystemdEnableResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$o: TaskFn<SystemdEnableParams, SystemdEnableResult>;
+declare const _default$23: TaskFn<SystemdEnableParams, SystemdEnableResult>;
 
 interface SystemdRestartParams {
     service: string;
@@ -1504,8 +2919,9 @@ interface SystemdRestartParams {
 }
 interface SystemdRestartResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$n: TaskFn<SystemdRestartParams, SystemdRestartResult>;
+declare const _default$22: TaskFn<SystemdRestartParams, SystemdRestartResult>;
 
 interface SystemdStartParams {
     service: string;
@@ -1513,8 +2929,9 @@ interface SystemdStartParams {
 }
 interface SystemdStartResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$m: TaskFn<SystemdStartParams, SystemdStartResult>;
+declare const _default$21: TaskFn<SystemdStartParams, SystemdStartResult>;
 
 interface SystemdStopParams {
     service: string;
@@ -1522,8 +2939,9 @@ interface SystemdStopParams {
 }
 interface SystemdStopResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$l: TaskFn<SystemdStopParams, SystemdStopResult>;
+declare const _default$20: TaskFn<SystemdStopParams, SystemdStopResult>;
 
 interface SystemdReloadParams {
     service: string;
@@ -1531,20 +2949,23 @@ interface SystemdReloadParams {
 }
 interface SystemdReloadResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$k: TaskFn<SystemdReloadParams, SystemdReloadResult>;
+declare const _default$1$: TaskFn<SystemdReloadParams, SystemdReloadResult>;
 
 interface SystemdStatusParams {
     service: string;
     sudo?: boolean;
 }
 interface SystemdStatusResult {
+    success: boolean;
     active: boolean;
+    error?: string;
 }
-declare const _default$j: TaskFn<SystemdStatusParams, SystemdStatusResult>;
+declare const _default$1_: TaskFn<SystemdStatusParams, SystemdStatusResult>;
 
 declare namespace systemd {
-  export { _default$p as disable, _default$o as enable, _default$k as reload, _default$n as restart, _default$m as start, _default$j as status, _default$l as stop };
+  export { _default$24 as disable, _default$23 as enable, _default$1$ as reload, _default$22 as restart, _default$21 as start, _default$1_ as status, _default$20 as stop };
 }
 
 interface TemplateWriteParams {
@@ -1561,63 +2982,122 @@ interface TemplateWriteResult {
     success: boolean;
     path: string;
 }
-declare const _default$i: TaskFn<TemplateWriteParams, TemplateWriteResult>;
+declare const _default$1Z: TaskFn<TemplateWriteParams, TemplateWriteResult>;
 
 declare namespace template {
-  export { _default$i as write };
+  export { _default$1Z as write };
+}
+
+interface UfwAllowParams {
+    port: string | number;
+    proto?: 'tcp' | 'udp';
+    from?: string;
+}
+interface UfwAllowResult {
+    success: boolean;
+    error?: string;
 }
+declare const _default$1Y: TaskFn<UfwAllowParams, UfwAllowResult>;
 
 interface UfwDenyParams {
-    from_addr?: string;
-    from_port?: number;
-    to_addr?: string;
-    to_port?: number;
+    port?: string | number;
+    proto?: 'tcp' | 'udp';
+    from?: string;
 }
 interface UfwDenyResult {
     success: boolean;
+    error?: string;
+}
+declare const _default$1X: TaskFn<UfwDenyParams, UfwDenyResult>;
+
+interface UfwDeleteParams {
+    rule_number: number;
+}
+interface UfwDeleteResult {
+    success: boolean;
+    error?: string;
 }
-declare const _default$h: TaskFn<UfwDenyParams, UfwDenyResult>;
+declare const _default$1W: TaskFn<UfwDeleteParams, UfwDeleteResult>;
 
 interface UfwDisableParams {
 }
 interface UfwDisableResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$g: TaskFn<UfwDisableParams, UfwDisableResult>;
+declare const _default$1V: TaskFn<UfwDisableParams, UfwDisableResult>;
 
 interface UfwEnableParams {
 }
 interface UfwEnableResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$f: TaskFn<UfwEnableParams, UfwEnableResult>;
+declare const _default$1U: TaskFn<UfwEnableParams, UfwEnableResult>;
 
 interface UfwInstallParams {
 }
 interface UfwInstallResult {
     success: boolean;
+    error?: string;
+}
+declare const _default$1T: TaskFn<UfwInstallParams, UfwInstallResult>;
+
+interface UfwLoggingParams {
+    level: 'on' | 'off' | 'low' | 'medium' | 'high' | 'full';
+}
+interface UfwLoggingResult {
+    success: boolean;
+    error?: string;
 }
-declare const _default$e: TaskFn<UfwInstallParams, UfwInstallResult>;
+declare const _default$1S: TaskFn<UfwLoggingParams, UfwLoggingResult>;
 
 interface UfwReloadParams {
 }
 interface UfwReloadResult {
     success: boolean;
+    error?: string;
+}
+declare const _default$1R: TaskFn<UfwReloadParams, UfwReloadResult>;
+
+interface UfwResetParams {
+}
+interface UfwResetResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$1Q: TaskFn<UfwResetParams, UfwResetResult>;
+
+interface UfwStatusParams {
+}
+interface UfwRule {
+    number: number;
+    to: string;
+    action: string;
+    from: string;
+    protocol?: string;
+    port?: string;
+}
+interface UfwStatusResult {
+    success: boolean;
+    status?: string;
+    rules?: UfwRule[];
+    error?: string;
 }
-declare const _default$d: TaskFn<UfwReloadParams, UfwReloadResult>;
+declare const _default$1P: TaskFn<UfwStatusParams, UfwStatusResult>;
 
 declare namespace ufw {
-  export { _default$h as deny, _default$g as disable, _default$f as enable, _default$e as install, _default$d as reload };
+  export { _default$1Y as allow, _default$1W as delete, _default$1X as deny, _default$1V as disable, _default$1U as enable, _default$1T as install, _default$1S as logging, _default$1R as reload, _default$1Q as reset, _default$1P as status };
 }
 
 interface AddGroupsParams {
     user: string;
-    groups: string[];
+    groups?: string | string[];
 }
 interface AddGroupsResult {
     success: boolean;
 }
-declare const _default$c: TaskFn<AddGroupsParams, AddGroupsResult>;
+declare const _default$1O: TaskFn<AddGroupsParams, AddGroupsResult>;
 
 interface CreateUserParams {
     user: string;
@@ -1628,8 +3108,9 @@ interface CreateUserParams {
 }
 interface CreateUserResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$b: TaskFn<CreateUserParams, CreateUserResult>;
+declare const _default$1N: TaskFn<CreateUserParams, CreateUserResult>;
 
 interface UserExistsParams {
     user: string;
@@ -1637,7 +3118,7 @@ interface UserExistsParams {
 interface UserExistsResult {
     exists: boolean;
 }
-declare const _default$a: TaskFn<UserExistsParams, UserExistsResult>;
+declare const _default$1M: TaskFn<UserExistsParams, UserExistsResult>;
 
 interface GetGidParams {
     user: string;
@@ -1646,7 +3127,7 @@ interface GetGidResult {
     success: boolean;
     gid: string;
 }
-declare const _default$9: TaskFn<GetGidParams, GetGidResult>;
+declare const _default$1L: TaskFn<GetGidParams, GetGidResult>;
 
 interface GetGroupsParams {
     user: string;
@@ -1655,7 +3136,7 @@ interface GetGroupsResult {
     success: boolean;
     groups: string[];
 }
-declare const _default$8: TaskFn<GetGroupsParams, GetGroupsResult>;
+declare const _default$1K: TaskFn<GetGroupsParams, GetGroupsResult>;
 
 interface GetUidParams {
     user: string;
@@ -1664,13 +3145,13 @@ interface GetUidResult {
     success: boolean;
     uid: string;
 }
-declare const _default$7: TaskFn<GetUidParams, GetUidResult>;
+declare const _default$1J: TaskFn<GetUidParams, GetUidResult>;
 
 interface GetUsernameResult {
     success: boolean;
     username: string;
 }
-declare const _default$6: TaskFn<{}, GetUsernameResult>;
+declare const _default$1I: TaskFn<{}, GetUsernameResult>;
 
 interface UserHomeDirParams {
     user: string;
@@ -1679,16 +3160,16 @@ interface UserHomeDirResult {
     path: string;
     exists: boolean;
 }
-declare const _default$5: TaskFn<UserHomeDirParams, UserHomeDirResult>;
+declare const _default$1H: TaskFn<UserHomeDirParams, UserHomeDirResult>;
 
 interface SetUserGroupsParams {
     user: string;
-    groups: string[];
+    groups?: string | string[];
 }
 interface SetUserGroupsResult {
     success: boolean;
 }
-declare const _default$4: TaskFn<SetUserGroupsParams, SetUserGroupsResult>;
+declare const _default$1G: TaskFn<SetUserGroupsParams, SetUserGroupsResult>;
 
 interface SetUserShellParams {
     user: string;
@@ -1697,7 +3178,7 @@ interface SetUserShellParams {
 interface SetUserShellResult {
     success: boolean;
 }
-declare const _default$3: TaskFn<SetUserShellParams, SetUserShellResult>;
+declare const _default$1F: TaskFn<SetUserShellParams, SetUserShellResult>;
 
 interface UserDeleteParams {
     user: string;
@@ -1710,7 +3191,7 @@ interface UserDeleteResult {
     success: boolean;
     error?: string;
 }
-declare const _default$2: TaskFn<UserDeleteParams, UserDeleteResult>;
+declare const _default$1E: TaskFn<UserDeleteParams, UserDeleteResult>;
 
 interface ModifyUserParams {
     user: string;
@@ -1729,8 +3210,9 @@ interface ModifyUserParams {
 }
 interface ModifyUserResult {
     success: boolean;
+    error?: string;
 }
-declare const _default$1: TaskFn<ModifyUserParams, ModifyUserResult>;
+declare const _default$1D: TaskFn<ModifyUserParams, ModifyUserResult>;
 
 type user_AddGroupsParams = AddGroupsParams;
 type user_AddGroupsResult = AddGroupsResult;
@@ -1754,26 +3236,2284 @@ type user_UserExistsResult = UserExistsResult;
 type user_UserHomeDirParams = UserHomeDirParams;
 type user_UserHomeDirResult = UserHomeDirResult;
 declare namespace user {
-  export { type user_AddGroupsParams as AddGroupsParams, type user_AddGroupsResult as AddGroupsResult, type user_CreateUserParams as CreateUserParams, type user_CreateUserResult as CreateUserResult, type user_GetGidParams as GetGidParams, type user_GetGidResult as GetGidResult, type user_GetGroupsParams as GetGroupsParams, type user_GetGroupsResult as GetGroupsResult, type user_GetUidParams as GetUidParams, type user_GetUidResult as GetUidResult, type user_GetUsernameResult as GetUsernameResult, type user_SetUserGroupsParams as SetUserGroupsParams, type user_SetUserGroupsResult as SetUserGroupsResult, type user_SetUserShellParams as SetUserShellParams, type user_SetUserShellResult as SetUserShellResult, type user_UserDeleteParams as UserDeleteParams, type user_UserDeleteResult as UserDeleteResult, type user_UserExistsParams as UserExistsParams, type user_UserExistsResult as UserExistsResult, type user_UserHomeDirParams as UserHomeDirParams, type user_UserHomeDirResult as UserHomeDirResult, _default$c as addGroups, _default$b as create, _default$2 as delete, _default$a as exists, _default$9 as getGid, _default$8 as getGroups, _default$7 as getUid, _default$6 as getUsername, _default$5 as homeDir, _default$1 as modify, _default$4 as setGroups, _default$3 as setShell };
+  export { type user_AddGroupsParams as AddGroupsParams, type user_AddGroupsResult as AddGroupsResult, type user_CreateUserParams as CreateUserParams, type user_CreateUserResult as CreateUserResult, type user_GetGidParams as GetGidParams, type user_GetGidResult as GetGidResult, type user_GetGroupsParams as GetGroupsParams, type user_GetGroupsResult as GetGroupsResult, type user_GetUidParams as GetUidParams, type user_GetUidResult as GetUidResult, type user_GetUsernameResult as GetUsernameResult, type user_SetUserGroupsParams as SetUserGroupsParams, type user_SetUserGroupsResult as SetUserGroupsResult, type user_SetUserShellParams as SetUserShellParams, type user_SetUserShellResult as SetUserShellResult, type user_UserDeleteParams as UserDeleteParams, type user_UserDeleteResult as UserDeleteResult, type user_UserExistsParams as UserExistsParams, type user_UserExistsResult as UserExistsResult, type user_UserHomeDirParams as UserHomeDirParams, type user_UserHomeDirResult as UserHomeDirResult, _default$1O as addGroups, _default$1N as create, _default$1E as delete, _default$1M as exists, _default$1L as getGid, _default$1K as getGroups, _default$1J as getUid, _default$1I as getUsername, _default$1H as homeDir, _default$1D as modify, _default$1G as setGroups, _default$1F as setShell };
 }
 
-declare const _default: {
-    echo: TaskFn<EchoParams, EchoResult>;
-    whoami: TaskFn<WhoamiParams, WhoamiResult>;
-    dir: typeof dir;
-    file: typeof file;
-    git: typeof git;
-    group: typeof group;
-    host: typeof host;
-    pkg: typeof pkg;
-    k3s: typeof k3s;
-    ssh: typeof ssh;
-    sudoers: typeof sudoers;
-    system: typeof system;
-    systemd: typeof systemd;
-    template: typeof template;
-    ufw: typeof ufw;
-    user: typeof user;
+interface XcpngListAttachedDisksParams {
+    vm_uuid: string;
+    include_readonly?: boolean;
+}
+interface XcpngAttachedDisk {
+    vbdUuid: string;
+    device?: string;
+    mode?: string;
+    type?: string;
+    currentlyAttached?: boolean;
+    vdiUuid?: string;
+    vdiNameLabel?: string;
+    vdiType?: string;
+    srUuid?: string;
+}
+interface XcpngListAttachedDisksResult {
+    success: boolean;
+    vmUuid?: string;
+    disks?: XcpngAttachedDisk[];
+    error?: string;
+}
+declare const _default$1C: TaskFn<XcpngListAttachedDisksParams, XcpngListAttachedDisksResult>;
+
+/**
+ * Supported input for filter-style arguments. Allows callers to pass:
+ * - an object map (`{ uuid: '...', name: 'foo' }`)
+ * - a single string (`"uuid=..."`)
+ * - an array of strings (`["uuid=...", "name=foo"]`)
+ */
+type XeFilterInput = Record<string, string | number | boolean | undefined | null> | string | string[] | undefined | null;
+
+interface XcpngListVbdsParams {
+    filters?: XeFilterInput;
+}
+type XcpngVbdRecord = Record<string, string> & {
+    params: Record<string, string>;
 };
+interface XcpngListVbdsResult {
+    success: boolean;
+    items?: XcpngVbdRecord[];
+    error?: string;
+}
+declare const _default$1B: TaskFn<XcpngListVbdsParams, XcpngListVbdsResult>;
+
+interface XcpngListVifsParams {
+    filters?: XeFilterInput;
+}
+type XcpngVifRecord = Record<string, string> & {
+    params: Record<string, string>;
+};
+interface XcpngListVifsResult {
+    success: boolean;
+    items?: XcpngVifRecord[];
+    error?: string;
+}
+declare const _default$1A: TaskFn<XcpngListVifsParams, XcpngListVifsResult>;
+
+interface XcpngGetVmInfoParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    allow_missing?: boolean;
+    include_vbds?: boolean;
+    include_vifs?: boolean;
+}
+interface XcpngVmInfo {
+    uuid: string;
+    nameLabel?: string;
+    powerState?: string;
+    params?: Record<string, string>;
+    memory?: {
+        staticMax?: number;
+        staticMin?: number;
+        dynamicMax?: number;
+        dynamicMin?: number;
+    };
+    vcpus?: {
+        max?: number;
+        atStartup?: number;
+    };
+    hvmBootPolicy?: string;
+    hvmBootParams?: {
+        raw: string | undefined;
+        values: Record<string, string>;
+    };
+    platform?: {
+        raw: string | undefined;
+        values: Record<string, string>;
+    };
+    otherConfig?: string;
+    residentOn?: string;
+}
+interface XcpngGetVmInfoResult {
+    success: boolean;
+    vmUuid?: string;
+    vm?: XcpngVmInfo;
+    vbds?: XcpngVbdRecord[];
+    vifs?: XcpngVifRecord[];
+    error?: string;
+    skipped?: boolean;
+}
+declare const _default$1z: TaskFn<XcpngGetVmInfoParams, XcpngGetVmInfoResult>;
+
+/**
+ * Parameters for powering off an XCP-ng VM.
+ * - `vm_uuid`: Target VM identifier.
+ * - `force`: When `true`, invokes `xe vm-shutdown --force` (immediate power-off). Defaults to graceful shutdown.
+ * - `timeout_seconds`: Optional grace period for `vm-shutdown`. When set, `xe` receives `--timeout=<seconds>`.
+ */
+interface XcpngStopVmParams {
+    vm_uuid: string;
+    force?: boolean;
+    timeout_seconds?: number;
+}
+/**
+ * Result containing the executed command details.
+ * - `command`: Final CLI invocation executed through `xe`.
+ * - `error`: Raw stderr output when the stop workflow fails.
+ */
+interface XcpngStopVmResult {
+    success: boolean;
+    command?: string;
+    error?: string;
+    alreadyHalted?: boolean;
+    initialPowerState?: string;
+    finalPowerState?: string;
+    waitAttempts?: number;
+}
+declare const _default$1y: TaskFn<XcpngStopVmParams, XcpngStopVmResult>;
+
+/**
+ * Parameters for powering on an XCP-ng VM.
+ * - `vm_uuid`: Target VM identifier.
+ * - `start_paused`: When `true`, boots the VM in a paused state (`xe vm-start --paused`).
+ * - `force`: When `true`, skips safety checks (maps to `xe vm-start --force`).
+ */
+interface XcpngStartVmParams {
+    vm_uuid: string;
+    start_paused?: boolean;
+    force?: boolean;
+}
+/**
+ * Result containing the executed command details.
+ * - `command`: Final CLI invocation executed through `xe`.
+ * - `error`: Raw stderr output when the start workflow fails.
+ */
+interface XcpngStartVmResult {
+    success: boolean;
+    command?: string;
+    error?: string;
+    alreadyRunning?: boolean;
+    initialPowerState?: string;
+    finalPowerState?: string;
+    waitAttempts?: number;
+}
+declare const _default$1x: TaskFn<XcpngStartVmParams, XcpngStartVmResult>;
+
+interface XcpngSnapshotVmParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    snapshot_name_label: string;
+    description?: string;
+    quiesce?: boolean;
+}
+interface XcpngSnapshotVmResult {
+    success: boolean;
+    vmUuid?: string;
+    snapshotUuid?: string;
+    command?: string;
+    error?: string;
+}
+declare const _default$1w: TaskFn<XcpngSnapshotVmParams, XcpngSnapshotVmResult>;
+
+interface XcpngUnplugVbdParams {
+    vbd_uuid: string;
+    allow_missing?: boolean;
+}
+interface XcpngUnplugVbdResult {
+    success: boolean;
+    command?: string;
+    alreadyDetached?: boolean;
+    error?: string;
+}
+declare const _default$1v: TaskFn<XcpngUnplugVbdParams, XcpngUnplugVbdResult>;
+
+interface XcpngResumeVmParams {
+    vm_uuid: string;
+    start_paused?: boolean;
+    host_uuid?: string;
+}
+interface XcpngResumeVmResult {
+    success: boolean;
+    command?: string;
+    alreadyRunning?: boolean;
+    initialPowerState?: string;
+    finalPowerState?: string;
+    waitAttempts?: number;
+    error?: string;
+}
+declare const _default$1u: TaskFn<XcpngResumeVmParams, XcpngResumeVmResult>;
+
+interface XcpngSuspendVmParams {
+    vm_uuid: string;
+    allow_running?: boolean;
+}
+interface XcpngSuspendVmResult {
+    success: boolean;
+    command?: string;
+    alreadySuspended?: boolean;
+    initialPowerState?: string;
+    finalPowerState?: string;
+    waitAttempts?: number;
+    error?: string;
+}
+declare const _default$1t: TaskFn<XcpngSuspendVmParams, XcpngSuspendVmResult>;
+
+interface XcpngSetVmResourcesParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    memory_mib?: number;
+    memory_static_min_mib?: number;
+    memory_static_max_mib?: number;
+    memory_dynamic_min_mib?: number;
+    memory_dynamic_max_mib?: number;
+    vcpus?: number;
+    vcpus_max?: number;
+    vcpus_at_startup?: number;
+}
+interface XcpngSetVmResourcesResult {
+    success: boolean;
+    vmUuid?: string;
+    appliedCommands: string[];
+    updatedMemoryBytes?: number;
+    updatedMemoryFields?: Record<string, number>;
+    updatedVcpus?: number;
+    updatedVcpusMax?: number;
+    updatedVcpusAtStartup?: number;
+    error?: string;
+    powerState?: string;
+    waitAttempts?: number;
+}
+declare const _default$1s: TaskFn<XcpngSetVmResourcesParams, XcpngSetVmResourcesResult>;
+
+/**
+ * Parameters for configuring VM boot behaviour.
+ * - `vm_uuid`: Target VM identifier.
+ * - `boot_order`: Boot sequence string recognised by XCP-ng (e.g., `cd`, `n`, `cdn`).
+ * - `firmware`: Optional firmware mode (`bios`, `uefi`). When set, updates `HVM-boot-params`.
+ */
+interface XcpngSetBootOrderParams {
+    vm_uuid: string;
+    boot_order: string;
+    firmware?: 'bios' | 'uefi';
+}
+/**
+ * Result describing the parameter updates issued for the VM.
+ * - `appliedCommands`: Ordered list of CLI commands executed.
+ * - `error`: Raw stderr output when a step fails.
+ */
+interface XcpngSetBootOrderResult {
+    success: boolean;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$1r: TaskFn<XcpngSetBootOrderParams, XcpngSetBootOrderResult>;
+
+interface XcpngSetSnapshotParamParams {
+    snapshot_uuid: string;
+    key: string;
+    value: string;
+}
+interface XcpngSetSnapshotParamResult {
+    success: boolean;
+    snapshotUuid?: string;
+    command?: string;
+    error?: string;
+}
+declare const _default$1q: TaskFn<XcpngSetSnapshotParamParams, XcpngSetSnapshotParamResult>;
+
+interface XcpngRevertSnapshotParams {
+    snapshot_uuid: string;
+}
+interface XcpngRevertSnapshotResult {
+    success: boolean;
+    snapshotUuid?: string;
+    vmUuid?: string;
+    command?: string;
+    error?: string;
+    powerState?: string;
+    waitAttempts?: number;
+}
+declare const _default$1p: TaskFn<XcpngRevertSnapshotParams, XcpngRevertSnapshotResult>;
+
+interface XcpngRemoveDiskParams {
+    vbd_uuid?: string;
+    vdi_uuid?: string;
+    vm_uuid?: string;
+    device?: string;
+    allow_missing?: boolean;
+    unplug?: boolean;
+    destroy_vbd?: boolean;
+    destroy_vdi?: boolean;
+}
+interface XcpngRemoveDiskResult {
+    success: boolean;
+    vbdUuid?: string;
+    vdiUuid?: string;
+    unplugged?: boolean;
+    destroyedVbd?: boolean;
+    destroyedVdi?: boolean;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$1o: TaskFn<XcpngRemoveDiskParams, XcpngRemoveDiskResult>;
+
+interface XcpngResizeVmMemoryParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    memory_mib: number;
+}
+interface XcpngResizeVmMemoryResult {
+    success: boolean;
+    vmUuid?: string;
+    appliedCommands: string[];
+    memoryBytes?: number;
+    error?: string;
+    powerState?: string;
+    waitAttempts?: number;
+}
+declare const _default$1n: TaskFn<XcpngResizeVmMemoryParams, XcpngResizeVmMemoryResult>;
+
+interface XcpngResizeVmCpusParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    vcpus?: number;
+    vcpus_max?: number;
+    vcpus_at_startup?: number;
+}
+interface XcpngResizeVmCpusResult {
+    success: boolean;
+    vmUuid?: string;
+    appliedCommands: string[];
+    vcpus?: number;
+    vcpusMax?: number;
+    vcpusAtStartup?: number;
+    error?: string;
+    powerState?: string;
+    waitAttempts?: number;
+}
+declare const _default$1m: TaskFn<XcpngResizeVmCpusParams, XcpngResizeVmCpusResult>;
+
+interface XcpngResizeVdiParams {
+    vdi_uuid?: string;
+    vdi_name_label?: string;
+    sr_uuid?: string;
+    new_size_bytes?: number;
+    new_size_mb?: number;
+    new_size_gb?: number;
+    new_size_mib?: number;
+    online?: boolean;
+}
+interface XcpngResizeVdiResult {
+    success: boolean;
+    vdiUuid?: string;
+    command?: string;
+    newSizeBytes?: number;
+    error?: string;
+}
+declare const _default$1l: TaskFn<XcpngResizeVdiParams, XcpngResizeVdiResult>;
+
+/**
+ * Parameters when querying VMs from an XCP-ng host.
+ * - `filters`: Key/value pairs passed directly to `xe vm-list` for server-side filtering.
+ *   Examples include `{ uuid: '...', 'resident-on': 'host-uuid' }`.
+ */
+interface XcpngListVmsParams {
+    filters?: XeFilterInput;
+    params?: 'all' | string | string[];
+}
+/**
+ * Result payload containing VM records.
+ * - `items`: Array of parsed metadata produced by `xe vm-list`.
+ * - `raw`: Original stdout for debugging or custom parsing.
+ * - `error`: Raw stderr output when the list operation fails.
+ */
+interface XcpngListVmsResult {
+    success: boolean;
+    items?: XcpngVmRecord[];
+    error?: string;
+}
+type XcpngVmRecord = Record<string, string> & {
+    params: Record<string, string>;
+};
+declare const _default$1k: TaskFn<XcpngListVmsParams, XcpngListVmsResult>;
+
+interface XcpngImportVdiParams {
+    sr_uuid?: string;
+    sr_name_label?: string;
+    filename: string;
+    vdi_name_label?: string;
+    description?: string;
+    type?: string;
+    virtual_size?: number;
+    force?: boolean;
+    uuid?: string;
+    format?: string;
+}
+interface XcpngImportVdiResult {
+    success: boolean;
+    srUuid?: string;
+    vdiUuid?: string;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$1j: TaskFn<XcpngImportVdiParams, XcpngImportVdiResult>;
+
+/**
+ * Parameters for querying VDIs.
+ * - `filters`: Filters passed to `xe vdi-list` (e.g., `{ 'sr-uuid': '...', type: 'user' }`).
+ */
+interface XcpngListVdisParams {
+    filters?: XeFilterInput;
+}
+/**
+ * Result payload for VDI listings.
+ * - `items`: Parsed records for each VDI returned by the host.
+ * - `raw`: Full stdout output for troubleshooting.
+ * - `error`: Raw stderr output when listing fails.
+ */
+type XcpngVdiRecord = Record<string, string> & {
+    params: Record<string, string>;
+};
+interface XcpngListVdisResult {
+    success: boolean;
+    items?: XcpngVdiRecord[];
+    error?: string;
+}
+declare const _default$1i: TaskFn<XcpngListVdisParams, XcpngListVdisResult>;
+
+interface XcpngListPifsParams {
+    filters?: XeFilterInput;
+}
+type XcpngPifRecord = Record<string, string> & {
+    params: Record<string, string>;
+};
+interface XcpngListPifsResult {
+    success: boolean;
+    items?: XcpngPifRecord[];
+    error?: string;
+}
+declare const _default$1h: TaskFn<XcpngListPifsParams, XcpngListPifsResult>;
+
+interface XcpngListTemplatesParams {
+    filters?: XeFilterInput;
+}
+type XcpngTemplateRecord = Record<string, string> & {
+    params: Record<string, string>;
+};
+interface XcpngListTemplatesResult {
+    success: boolean;
+    items?: XcpngTemplateRecord[];
+    error?: string;
+}
+declare const _default$1g: TaskFn<XcpngListTemplatesParams, XcpngListTemplatesResult>;
+
+interface XcpngListNetworksParams {
+    filters?: XeFilterInput;
+}
+type XcpngNetworkRecord = Record<string, string> & {
+    params: Record<string, string>;
+};
+interface XcpngListNetworksResult {
+    success: boolean;
+    items?: XcpngNetworkRecord[];
+    error?: string;
+}
+declare const _default$1f: TaskFn<XcpngListNetworksParams, XcpngListNetworksResult>;
+
+/**
+ * Parameters for querying storage repositories.
+ * - `filters`: Filters passed to `xe sr-list` (e.g., `{ 'name-label': 'Local storage' }`).
+ */
+interface XcpngListStorageRepositoriesParams {
+    filters?: XeFilterInput;
+}
+/**
+ * Result payload for storage repository listings.
+ * - `items`: Parsed SR metadata records.
+ * - `raw`: Full stdout output captured from the host.
+ * - `error`: Raw stderr when the list operation fails.
+ */
+type XcpngStorageRepositoryRecord = Record<string, string> & {
+    params: Record<string, string>;
+};
+interface XcpngListStorageRepositoriesResult {
+    success: boolean;
+    items?: XcpngStorageRepositoryRecord[];
+    error?: string;
+}
+declare const _default$1e: TaskFn<XcpngListStorageRepositoriesParams, XcpngListStorageRepositoriesResult>;
+
+interface XcpngUploadIsoParams {
+    /** Path to the ISO on the local machine running hostctl. */
+    source_path: string;
+    /** Name-label of the ISO SR to ensure exists before uploading. */
+    iso_sr_name: string;
+    /**
+     * Directory on the hypervisor where ISOs should reside. Defaults to `/var/opt/xen/iso-sr`.
+     * Must align with the location configured on the SR.
+     */
+    location?: string;
+    /**
+     * Override the destination file name (defaults to the basename of `source_path`).
+     */
+    filename?: string;
+    /**
+     * When false (default), the upload is skipped if a file already exists at the destination.
+     */
+    overwrite?: boolean;
+    /** Plumbed through to `find-or-create-iso-sr` for directory ownership. */
+    location_owner?: string;
+    /** Plumbed through to `find-or-create-iso-sr` for directory permissions. */
+    location_mode?: string;
+    /** Optional chunk size (in MiB) used when streaming the ISO to the hypervisor. Defaults to 128MiB. */
+    chunk_size_mb?: number;
+}
+interface XcpngUploadIsoHostResult {
+    success: boolean;
+    uploaded: boolean;
+    skipped?: boolean;
+    srUuid?: string;
+    createdSr?: boolean;
+    remotePath?: string;
+    error?: string;
+}
+interface XcpngUploadIsoResult {
+    success: boolean;
+    uploads: Record<string, XcpngUploadIsoHostResult | Error>;
+    error?: string;
+}
+declare const _default$1d: TaskFn<XcpngUploadIsoParams, XcpngUploadIsoResult>;
+
+interface XcpngProvisionVmParams {
+    vm_name_label: string;
+    vm_description?: string;
+    template_uuid?: string;
+    template_name_label?: string;
+    destination_sr_uuid?: string;
+    destination_sr_name_label?: string;
+    disk_name_label?: string;
+    disk_description?: string;
+    disk_device?: string;
+    disk_size_bytes?: number;
+    disk_size_mb?: number;
+    disk_size_mib?: number;
+    disk_size_gb?: number;
+    disk_size_gib?: number;
+    vcpus?: number;
+    memory_mib?: number;
+    memory_mb?: number;
+    memory_gb?: number;
+    memory_gib?: number;
+    virtualization_mode?: 'pv' | 'pvhvm';
+    device_model?: 'qemu_traditional' | 'qemu-upstream-compat';
+    boot_order?: string;
+    boot_firmware?: 'bios' | 'uefi';
+    boot_efi_file?: string;
+    network_uuid?: string;
+    network_name_label?: string;
+    network_device?: string;
+    network_mac_address?: string;
+    network_mtu?: number;
+    start_vm?: boolean;
+    start_paused?: boolean;
+    start_force?: boolean;
+    cloud_init_user_data?: string;
+    cloud_init_user_data_b64?: string;
+    cloud_init_user_data_path?: string;
+    cloud_init_network_config?: string;
+    cloud_init_network_config_b64?: string;
+    cloud_init_network_config_path?: string;
+    cloud_init_hostname?: string;
+    cloud_init_instance_id?: string;
+    config_drive_enabled?: boolean;
+    config_drive_force?: boolean;
+    config_drive_sr_uuid?: string;
+    config_drive_sr_name_label?: string;
+    config_drive_sr_location?: string;
+    config_drive_sr_location_owner?: string;
+    config_drive_sr_location_mode?: string;
+    config_drive_iso_filename?: string;
+    config_drive_overwrite?: boolean;
+    config_drive_volume_id?: string;
+    config_drive_detach_after_start?: boolean;
+    config_drive_detach_delay_seconds?: number;
+    config_drive_keep_vdi?: boolean;
+}
+interface XcpngProvisionVmStep {
+    name: string;
+    success: boolean;
+    details?: Record<string, unknown>;
+    error?: string;
+}
+interface XcpngProvisionVmResult {
+    success: boolean;
+    vmUuid?: string;
+    templateUuid?: string;
+    sourceVdiUuid?: string;
+    clonedVdiUuid?: string;
+    destinationSrUuid?: string;
+    rootVbdUuid?: string;
+    vifUuid?: string;
+    configDriveVdiUuid?: string;
+    configDriveIsoPath?: string;
+    configDriveSrUuid?: string;
+    configDriveReused?: boolean;
+    commands: string[];
+    steps: XcpngProvisionVmStep[];
+    error?: string;
+    skipped?: boolean;
+}
+declare const _default$1c: TaskFn<XcpngProvisionVmParams, XcpngProvisionVmResult>;
+
+interface XcpngProvisionVmFromIsoParams {
+    /** Human readable VM name. */
+    vm_name_label: string;
+    /** Optional VM description. */
+    vm_description?: string;
+    /** Template UUID to clone. Takes precedence over `template_name_label`. */
+    template_uuid?: string;
+    /** Template name to resolve when UUID is not provided. */
+    template_name_label?: string;
+    /** Memory allocation in MiB (applied to static/dynamic bounds). */
+    memory_mib?: number;
+    /** Memory allocation in MB (converted to MiB when applied). */
+    memory_mb?: number;
+    /** Number of vCPUs to configure. */
+    vcpus?: number;
+    /** Virtualization mode to apply to the VM (defaults to PVHVM). */
+    virtualization_mode?: 'pv' | 'pvhvm';
+    /** Device model applied after cloning (defaults to qemu-upstream-compat). */
+    device_model?: 'qemu_traditional' | 'qemu-upstream-compat';
+    /** Root disk name. Defaults to `<vm_name_label>-root`. */
+    root_disk_name_label?: string;
+    /** Storage repository UUID to host the root disk. */
+    root_disk_sr_uuid?: string;
+    /** Storage repository name-label used when the UUID is not provided. */
+    root_disk_sr_name_label?: string;
+    /** Size of the root disk (provide exactly one of bytes/MB/GB). */
+    root_disk_size_bytes?: number;
+    root_disk_size_mb?: number;
+    root_disk_size_gb?: number;
+    /** Optional description for the root disk. */
+    root_disk_description?: string;
+    /** Device slot for the root disk (defaults to `0`). */
+    root_disk_device?: string;
+    /** Network UUID to attach. */
+    network_uuid?: string;
+    /** Network name-label used when UUID is not provided. */
+    network_name_label?: string;
+    /** Optional VIF slot (defaults to `0`). */
+    network_device?: string;
+    /** Optional static MAC address. */
+    network_mac_address?: string;
+    /** Optional MTU for the VIF. */
+    network_mtu?: number;
+    /** ISO VDI UUID if already known. */
+    iso_vdi_uuid?: string;
+    /** ISO VDI name-label used for lookup when UUID is not provided. */
+    iso_name_label?: string;
+    /** Storage repository UUID that houses the ISO when resolving by name. */
+    iso_sr_uuid?: string;
+    /** Device slot for the virtual CD drive (defaults to hypervisor selection). */
+    iso_device?: string;
+    /** Whether to eject existing media before inserting the ISO (default true). */
+    iso_eject_before_insert?: boolean;
+    /** Explicit boot order string (defaults to `cd` so the ISO is attempted first). */
+    boot_order?: string;
+    /** Optional firmware mode applied alongside boot order. */
+    boot_firmware?: 'bios' | 'uefi';
+    /** When true, powers on the VM after configuration. */
+    start_vm?: boolean;
+    /** Maps to `xe vm-start --paused`. */
+    start_paused?: boolean;
+    /** Maps to `xe vm-start --force`. */
+    start_force?: boolean;
+}
+interface XcpngProvisionVmFromIsoStep {
+    name: string;
+    success: boolean;
+    details?: Record<string, unknown>;
+    error?: string;
+}
+interface XcpngProvisionVmFromIsoResult {
+    success: boolean;
+    vmUuid?: string;
+    templateUuid?: string;
+    rootDiskUuid?: string;
+    rootVbdUuid?: string;
+    rootDiskSrUuid?: string;
+    networkVifUuid?: string;
+    isoVdiUuid?: string;
+    commands: string[];
+    steps: XcpngProvisionVmFromIsoStep[];
+    error?: string;
+}
+declare const _default$1b: TaskFn<XcpngProvisionVmFromIsoParams, XcpngProvisionVmFromIsoResult>;
+
+interface XcpngImportIsoParams {
+    /** ISO SR name-label that should surface the ISO. */
+    iso_sr_name: string;
+    /**
+     * ISO file name (or full path) within the SR location. When a path is supplied, the directory
+     * portion is treated as the SR location unless `location` is explicitly provided.
+     */
+    iso_filename: string;
+    /**
+     * Filesystem location on the hypervisor where ISO files live. Defaults to `/var/opt/xen/iso-sr`
+     * or the directory component of `iso_filename` when provided.
+     */
+    location?: string;
+    /** Owner passed to `core.dir.create` when ensuring the location exists. */
+    location_owner?: string;
+    /** Mode passed to `core.dir.create` when ensuring the location exists. */
+    location_mode?: string;
+    /**
+     * When true (default), runs `xe sr-scan` before attempting an import so the SR indexes new files.
+     */
+    rescan?: boolean;
+    /**
+     * When true (default), calls `xe vdi-import` if the VDI is still missing after a rescan. Set to
+     * false to only rescan and report absence.
+     */
+    import_when_missing?: boolean;
+}
+interface XcpngImportIsoResult {
+    success: boolean;
+    srUuid?: string;
+    createdSr?: boolean;
+    vdiUuid?: string;
+    vdi?: Record<string, string>;
+    wasImported?: boolean;
+    rescanned?: boolean;
+    commands: string[];
+    error?: string;
+}
+declare const _default$1a: TaskFn<XcpngImportIsoParams, XcpngImportIsoResult>;
+
+interface XcpngFindNetworkParams {
+    name_label?: string;
+    uuid?: string;
+    filters?: XeFilterInput;
+    allow_multiple?: boolean;
+    fail_when_missing?: boolean;
+}
+interface XcpngFindNetworkResult {
+    success: boolean;
+    network?: XcpngNetworkRecord;
+    matches?: XcpngNetworkRecord[];
+    multiple?: boolean;
+    error?: string;
+}
+declare const _default$19: TaskFn<XcpngFindNetworkParams, XcpngFindNetworkResult>;
+
+interface XcpngFindStorageRepositoryParams {
+    name_label?: string;
+    uuid?: string;
+    type?: string;
+    content_type?: string;
+    filters?: XcpngListStorageRepositoriesParams['filters'];
+    allow_multiple?: boolean;
+    fail_when_missing?: boolean;
+}
+interface XcpngFindStorageRepositoryResult {
+    success: boolean;
+    storageRepository?: XcpngStorageRepositoryRecord;
+    matches?: XcpngStorageRepositoryRecord[];
+    multiple?: boolean;
+    error?: string;
+}
+declare const _default$18: TaskFn<XcpngFindStorageRepositoryParams, XcpngFindStorageRepositoryResult>;
+
+interface XcpngFindOrCreateIsoSrParams {
+    /** Desired `name-label` for the ISO SR. */
+    name_label: string;
+    /** Optional `name-description` to apply when the SR is created. */
+    description?: string;
+    /**
+     * Filesystem path on the hypervisor that contains ISO images.
+     * Defaults to `/var/opt/xen/iso-sr` when not provided.
+     */
+    location?: string;
+    /**
+     * Owner passed to `core.dir.create` when ensuring the location exists.
+     * Defaults to `root` because ISO SR paths typically live under `/var`.
+     */
+    location_owner?: string;
+    /**
+     * Mode passed to `core.dir.create` when ensuring the location exists.
+     */
+    location_mode?: string;
+    /** Optional host UUID to scope SR creation. Rarely required for ISO SRs. */
+    host_uuid?: string;
+    /**
+     * Explicitly control the legacy mode flag on the SR (defaults to true, matching XCP-ng tooling).
+     * Set to false to omit the legacy mode flag.
+     */
+    legacy_mode?: boolean;
+    /**
+     * Additional device-config entries to include when creating the SR.
+     * Keys map to the suffix after `device-config:` (e.g., `{ legacy_mode: 'true' }`).
+     */
+    device_config?: Record<string, string | number | boolean | undefined | null>;
+    /**
+     * Additional other-config entries to include when creating the SR.
+     * Keys map to the suffix after `other-config:` (e.g., `{ auto-scan: 'true' }`).
+     */
+    other_config?: Record<string, string | number | boolean | undefined | null>;
+}
+interface XcpngFindOrCreateIsoSrResult {
+    success: boolean;
+    created: boolean;
+    /** UUID for the located or newly created SR. */
+    srUuid?: string;
+    /** Parsed SR metadata returned from `xe sr-list`. */
+    sr?: Record<string, string>;
+    /** Commands executed during creation (empty when SR already exists). */
+    commands: string[];
+    error?: string;
+}
+declare const _default$17: TaskFn<XcpngFindOrCreateIsoSrParams, XcpngFindOrCreateIsoSrResult>;
+
+interface XcpngFindVmParams {
+    name_label?: string;
+    uuid?: string;
+    filters?: XcpngListVmsParams['filters'];
+    allow_multiple?: boolean;
+    fail_when_missing?: boolean;
+    params?: XcpngListVmsParams['params'];
+}
+interface XcpngFindVmResult {
+    success: boolean;
+    vm?: XcpngVmRecord;
+    matches?: XcpngVmRecord[];
+    multiple?: boolean;
+    error?: string;
+}
+declare const _default$16: TaskFn<XcpngFindVmParams, XcpngFindVmResult>;
+
+interface XcpngFindVdiParams {
+    name_label?: string;
+    uuid?: string;
+    sr_uuid?: string;
+    filters?: XcpngListVdisParams['filters'];
+    allow_multiple?: boolean;
+    fail_when_missing?: boolean;
+}
+interface XcpngFindVdiResult {
+    success: boolean;
+    vdi?: Record<string, string>;
+    matches?: Array<Record<string, string>>;
+    multiple?: boolean;
+    error?: string;
+}
+declare const _default$15: TaskFn<XcpngFindVdiParams, XcpngFindVdiResult>;
+
+interface XcpngFindTemplateParams {
+    name_label?: string;
+    uuid?: string;
+    filters?: XcpngListTemplatesParams['filters'];
+    allow_multiple?: boolean;
+    fail_when_missing?: boolean;
+}
+interface XcpngFindTemplateResult {
+    success: boolean;
+    template?: Record<string, string>;
+    matches?: Array<Record<string, string>>;
+    multiple?: boolean;
+    error?: string;
+}
+declare const _default$14: TaskFn<XcpngFindTemplateParams, XcpngFindTemplateResult>;
+
+interface XcpngRebootVmParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    force?: boolean;
+}
+interface XcpngRebootVmResult {
+    success: boolean;
+    vmUuid?: string;
+    command?: string;
+    error?: string;
+    powerState?: string;
+    waitAttempts?: number;
+}
+declare const _default$13: TaskFn<XcpngRebootVmParams, XcpngRebootVmResult>;
+
+interface XcpngSetPifParamParams {
+    pif_uuid: string;
+    key: string;
+    value: string;
+}
+interface XcpngSetPifParamResult {
+    success: boolean;
+    pifUuid?: string;
+    command?: string;
+    error?: string;
+}
+declare const _default$12: TaskFn<XcpngSetPifParamParams, XcpngSetPifParamResult>;
+
+interface XcpngUnplugPifParams {
+    pif_uuid?: string;
+    device?: string;
+    host_uuid?: string;
+    host_name_label?: string;
+    allow_missing?: boolean;
+}
+interface XcpngUnplugPifResult {
+    success: boolean;
+    pifUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$11: TaskFn<XcpngUnplugPifParams, XcpngUnplugPifResult>;
+
+interface XcpngPifScanParams {
+    host_uuid?: string;
+    host_name_label?: string;
+    allow_missing?: boolean;
+}
+interface XcpngPifScanResult {
+    success: boolean;
+    hostUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$10: TaskFn<XcpngPifScanParams, XcpngPifScanResult>;
+
+interface XcpngPlugPifParams {
+    pif_uuid?: string;
+    device?: string;
+    host_uuid?: string;
+    host_name_label?: string;
+    allow_missing?: boolean;
+}
+interface XcpngPlugPifResult {
+    success: boolean;
+    pifUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$$: TaskFn<XcpngPlugPifParams, XcpngPlugPifResult>;
+
+interface XcpngSetSrParamParams {
+    sr_uuid?: string;
+    sr_name_label?: string;
+    key: string;
+    value: string;
+}
+interface XcpngSetSrParamResult {
+    success: boolean;
+    srUuid?: string;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$_: TaskFn<XcpngSetSrParamParams, XcpngSetSrParamResult>;
+
+interface XcpngSetNetworkParamParams {
+    network_uuid?: string;
+    network_name_label?: string;
+    key: string;
+    value: string;
+}
+interface XcpngSetNetworkParamResult {
+    success: boolean;
+    networkUuid?: string;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$Z: TaskFn<XcpngSetNetworkParamParams, XcpngSetNetworkParamResult>;
+
+interface XcpngSetPoolParamParams {
+    pool_uuid?: string;
+    pool_name_label?: string;
+    key: string;
+    value: string;
+}
+interface XcpngSetPoolParamResult {
+    success: boolean;
+    poolUuid?: string;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$Y: TaskFn<XcpngSetPoolParamParams, XcpngSetPoolParamResult>;
+
+interface XcpngListPoolsParams {
+    filters?: XeFilterInput;
+}
+interface XcpngListPoolsResult {
+    success: boolean;
+    items?: Array<Record<string, string>>;
+    error?: string;
+}
+declare const _default$X: TaskFn<XcpngListPoolsParams, XcpngListPoolsResult>;
+
+interface XcpngFindPoolParams {
+    uuid?: string;
+    name_label?: string;
+    filters?: XcpngListPoolsParams['filters'];
+    allow_multiple?: boolean;
+    fail_when_missing?: boolean;
+}
+interface XcpngFindPoolResult {
+    success: boolean;
+    pool?: Record<string, string>;
+    matches?: Array<Record<string, string>>;
+    multiple?: boolean;
+    error?: string;
+}
+declare const _default$W: TaskFn<XcpngFindPoolParams, XcpngFindPoolResult>;
+
+interface XcpngUnplugPbdParams {
+    pbd_uuid?: string;
+    sr_uuid?: string;
+    host_uuid?: string;
+    allow_missing?: boolean;
+}
+interface XcpngUnplugPbdResult {
+    success: boolean;
+    pbdUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$V: TaskFn<XcpngUnplugPbdParams, XcpngUnplugPbdResult>;
+
+interface XcpngPlugPbdParams {
+    pbd_uuid?: string;
+    sr_uuid?: string;
+    host_uuid?: string;
+    allow_missing?: boolean;
+}
+interface XcpngPlugPbdResult {
+    success: boolean;
+    pbdUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$U: TaskFn<XcpngPlugPbdParams, XcpngPlugPbdResult>;
+
+interface XcpngDestroyPbdParams {
+    pbd_uuid?: string;
+    host_uuid?: string;
+    host_name_label?: string;
+    sr_uuid?: string;
+    sr_name_label?: string;
+    allow_missing?: boolean;
+}
+interface XcpngDestroyPbdResult {
+    success: boolean;
+    pbdUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$T: TaskFn<XcpngDestroyPbdParams, XcpngDestroyPbdResult>;
+
+interface XcpngCreatePbdParams {
+    host_uuid?: string;
+    host_name_label?: string;
+    sr_uuid?: string;
+    sr_name_label?: string;
+    device_config?: Record<string, string | number | boolean>;
+    other_config?: Record<string, string | number | boolean>;
+    allow_existing?: boolean;
+}
+interface XcpngCreatePbdResult {
+    success: boolean;
+    pbdUuid?: string;
+    hostUuid?: string;
+    srUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$S: TaskFn<XcpngCreatePbdParams, XcpngCreatePbdResult>;
+
+interface XcpngListPbdsParams {
+    filters?: XeFilterInput;
+}
+type XcpngPbdRecord = Record<string, string> & {
+    params: Record<string, string>;
+};
+interface XcpngListPbdsResult {
+    success: boolean;
+    items?: XcpngPbdRecord[];
+    error?: string;
+}
+declare const _default$R: TaskFn<XcpngListPbdsParams, XcpngListPbdsResult>;
+
+interface XcpngFindPbdParams {
+    uuid?: string;
+    sr_uuid?: string;
+    host_uuid?: string;
+    filters?: XcpngListPbdsParams['filters'];
+    allow_multiple?: boolean;
+    fail_when_missing?: boolean;
+}
+interface XcpngFindPbdResult {
+    success: boolean;
+    pbd?: XcpngPbdRecord;
+    matches?: XcpngPbdRecord[];
+    multiple?: boolean;
+    error?: string;
+}
+declare const _default$Q: TaskFn<XcpngFindPbdParams, XcpngFindPbdResult>;
+
+interface XcpngEvacuateHostParams {
+    host_uuid?: string;
+    host_name_label?: string;
+    allow_missing?: boolean;
+}
+interface XcpngEvacuateHostResult {
+    success: boolean;
+    hostUuid?: string;
+    command?: string;
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$P: TaskFn<XcpngEvacuateHostParams, XcpngEvacuateHostResult>;
+
+interface XcpngShutdownHostParams {
+    host_uuid?: string;
+    host_name_label?: string;
+    force?: boolean;
+    allow_missing?: boolean;
+}
+interface XcpngShutdownHostResult {
+    success: boolean;
+    hostUuid?: string;
+    command?: string;
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$O: TaskFn<XcpngShutdownHostParams, XcpngShutdownHostResult>;
+
+interface XcpngRebootHostParams {
+    host_uuid?: string;
+    host_name_label?: string;
+    force?: boolean;
+    allow_missing?: boolean;
+}
+interface XcpngRebootHostResult {
+    success: boolean;
+    hostUuid?: string;
+    command?: string;
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$N: TaskFn<XcpngRebootHostParams, XcpngRebootHostResult>;
+
+interface XcpngDisableHostParams {
+    host_uuid?: string;
+    host_name_label?: string;
+    allow_missing?: boolean;
+    force?: boolean;
+    evacuate?: boolean;
+}
+interface XcpngDisableHostResult {
+    success: boolean;
+    hostUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    evacuated?: boolean;
+    error?: string;
+}
+declare const _default$M: TaskFn<XcpngDisableHostParams, XcpngDisableHostResult>;
+
+interface XcpngEnableHostParams {
+    host_uuid?: string;
+    host_name_label?: string;
+    allow_missing?: boolean;
+    force?: boolean;
+}
+interface XcpngEnableHostResult {
+    success: boolean;
+    hostUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$L: TaskFn<XcpngEnableHostParams, XcpngEnableHostResult>;
+
+interface XcpngListHostsParams {
+    filters?: XeFilterInput;
+}
+interface XcpngListHostsResult {
+    success: boolean;
+    items?: Array<Record<string, string>>;
+    error?: string;
+}
+declare const _default$K: TaskFn<XcpngListHostsParams, XcpngListHostsResult>;
+
+interface XcpngFindHostParams {
+    name_label?: string;
+    uuid?: string;
+    filters?: XcpngListHostsParams['filters'];
+    allow_multiple?: boolean;
+    fail_when_missing?: boolean;
+}
+interface XcpngFindHostResult {
+    success: boolean;
+    host?: Record<string, string>;
+    matches?: Array<Record<string, string>>;
+    multiple?: boolean;
+    error?: string;
+}
+declare const _default$J: TaskFn<XcpngFindHostParams, XcpngFindHostResult>;
+
+interface XcpngClearMessagesParams {
+    uuid?: string;
+    uuid_prefix?: string;
+    all?: boolean;
+    filters?: XeFilterInput;
+}
+interface XcpngClearMessagesResult {
+    success: boolean;
+    cleared?: Array<string>;
+    commands?: Array<string>;
+    error?: string;
+}
+declare const _default$I: TaskFn<XcpngClearMessagesParams, XcpngClearMessagesResult>;
+
+interface XcpngListMessagesParams {
+    filters?: XeFilterInput;
+}
+interface XcpngListMessagesResult {
+    success: boolean;
+    items?: Array<Record<string, string>>;
+    error?: string;
+}
+declare const _default$H: TaskFn<XcpngListMessagesParams, XcpngListMessagesResult>;
+
+interface XcpngListSnapshotsParams {
+    filters?: XeFilterInput;
+}
+interface XcpngListSnapshotsResult {
+    success: boolean;
+    items?: Array<Record<string, string>>;
+    error?: string;
+}
+declare const _default$G: TaskFn<XcpngListSnapshotsParams, XcpngListSnapshotsResult>;
+
+interface XcpngForgetSrParams {
+    sr_uuid?: string;
+    sr_name_label?: string;
+    allow_missing?: boolean;
+}
+interface XcpngForgetSrResult {
+    success: boolean;
+    srUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$F: TaskFn<XcpngForgetSrParams, XcpngForgetSrResult>;
+
+interface XcpngIntroduceSrParams {
+    sr_uuid: string;
+    name_label?: string;
+    type?: string;
+    content_type?: string;
+    shared?: boolean;
+}
+interface XcpngIntroduceSrResult {
+    success: boolean;
+    srUuid?: string;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$E: TaskFn<XcpngIntroduceSrParams, XcpngIntroduceSrResult>;
+
+interface XcpngDestroySrParams {
+    sr_uuid?: string;
+    sr_name_label?: string;
+    allow_missing?: boolean;
+    force?: boolean;
+}
+interface XcpngDestroySrResult {
+    success: boolean;
+    srUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$D: TaskFn<XcpngDestroySrParams, XcpngDestroySrResult>;
+
+interface XcpngCreateSrParams {
+    name_label: string;
+    type: string;
+    device_config: Record<string, string>;
+    content_type?: string;
+    description?: string;
+    allow_existing?: boolean;
+}
+interface XcpngCreateSrResult {
+    success: boolean;
+    srUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$C: TaskFn<XcpngCreateSrParams, XcpngCreateSrResult>;
+
+interface XcpngDetachVdiParams {
+    vbd_uuid?: string;
+    vm_uuid?: string;
+    vdi_uuid?: string;
+    device?: string;
+    allow_missing?: boolean;
+    destroy_vbd?: boolean;
+    destroy_vdi?: boolean;
+}
+interface XcpngDetachVdiResult {
+    success: boolean;
+    vbdUuid?: string;
+    vdiUuid?: string;
+    unplugged?: boolean;
+    destroyedVbd?: boolean;
+    destroyedVdi?: boolean;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$B: TaskFn<XcpngDetachVdiParams, XcpngDetachVdiResult>;
+
+interface XcpngDetachNetworkInterfaceParams {
+    vif_uuid?: string;
+    vm_uuid?: string;
+    device?: string;
+    allow_missing?: boolean;
+    destroy_record?: boolean;
+}
+interface XcpngDetachNetworkInterfaceResult {
+    success: boolean;
+    vifUuid?: string;
+    unplugged?: boolean;
+    destroyed?: boolean;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$A: TaskFn<XcpngDetachNetworkInterfaceParams, XcpngDetachNetworkInterfaceResult>;
+
+interface XcpngDetachIsoParams {
+    vm_uuid: string;
+    allow_missing?: boolean;
+}
+interface XcpngDetachIsoResult {
+    success: boolean;
+    command?: string;
+    ejected?: boolean;
+    alreadyEmpty?: boolean;
+    error?: string;
+}
+declare const _default$z: TaskFn<XcpngDetachIsoParams, XcpngDetachIsoResult>;
+
+interface XcpngVmImportParams {
+    filename: string;
+    sr_uuid?: string;
+    sr_name_label?: string;
+    new_name_label?: string;
+    preserve_mac_addresses?: boolean;
+    force?: boolean;
+}
+interface XcpngVmImportResult {
+    success: boolean;
+    srUuid?: string;
+    importedVmUuid?: string;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$y: TaskFn<XcpngVmImportParams, XcpngVmImportResult>;
+
+interface XcpngVmExportParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    vm_filters?: XcpngFindVmParams['filters'];
+    remote_path: string;
+    compress?: boolean;
+    live?: boolean;
+    force?: boolean;
+    allow_missing?: boolean;
+}
+interface XcpngVmExportResult {
+    success: boolean;
+    vmUuid?: string;
+    outputPath?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$x: TaskFn<XcpngVmExportParams, XcpngVmExportResult>;
+
+interface XcpngVmMigrateParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    vm_filters?: XcpngFindVmParams['filters'];
+    destination_host_uuid?: string;
+    destination_host_name_label?: string;
+    destination_sr_uuid?: string;
+    destination_sr_name_label?: string;
+    live?: boolean;
+    force?: boolean;
+    allow_missing?: boolean;
+}
+interface XcpngVmMigrateResult {
+    success: boolean;
+    vmUuid?: string;
+    destinationHostUuid?: string;
+    destinationSrUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$w: TaskFn<XcpngVmMigrateParams, XcpngVmMigrateResult>;
+
+interface XcpngVmCopyParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    vm_filters?: XcpngFindVmParams['filters'];
+    destination_sr_uuid?: string;
+    destination_sr_name_label?: string;
+    new_name_label?: string;
+    description?: string;
+    force?: boolean;
+    allow_missing?: boolean;
+}
+interface XcpngVmCopyResult {
+    success: boolean;
+    sourceVmUuid?: string;
+    newVmUuid?: string;
+    destinationSrUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$v: TaskFn<XcpngVmCopyParams, XcpngVmCopyResult>;
+
+interface XcpngExportVdiParams {
+    vdi_uuid?: string;
+    vdi_name_label?: string;
+    sr_uuid?: string;
+    filters?: XcpngFindVdiParams['filters'];
+    remote_path: string;
+    export_format?: 'raw' | 'vhd' | 'vhd.gz';
+    allow_missing?: boolean;
+}
+interface XcpngExportVdiResult {
+    success: boolean;
+    vdiUuid?: string;
+    outputPath?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$u: TaskFn<XcpngExportVdiParams, XcpngExportVdiResult>;
+
+interface XcpngCopyVdiParams {
+    source_vdi_uuid?: string;
+    source_vdi_name_label?: string;
+    source_sr_uuid?: string;
+    destination_sr_uuid?: string;
+    destination_sr_name_label?: string;
+    new_name_label?: string;
+    description?: string;
+    sharable?: boolean;
+    allow_missing?: boolean;
+    filters?: XcpngFindVdiParams['filters'];
+}
+interface XcpngCopyVdiResult {
+    success: boolean;
+    sourceVdiUuid?: string;
+    destinationSrUuid?: string;
+    sourceSrUuid?: string;
+    newVdiUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$t: TaskFn<XcpngCopyVdiParams, XcpngCopyVdiResult>;
+
+interface XcpngDestroyVmParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    force?: boolean;
+    destroy_snapshots?: boolean;
+    destroy_vdis?: boolean;
+    allow_missing?: boolean;
+    filters?: Record<string, string | number | boolean | undefined | null>;
+}
+interface XcpngDestroyVmResult {
+    success: boolean;
+    vmUuid?: string;
+    command?: string;
+    commands?: string[];
+    destroyedVdiUuids?: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$s: TaskFn<XcpngDestroyVmParams, XcpngDestroyVmResult>;
+
+interface XcpngDestroyVdiParams {
+    /** Target VDI UUID. */
+    vdi_uuid?: string;
+    /** Optional VDI name-label used to resolve the UUID when vdi_uuid is not supplied. */
+    vdi_name_label?: string;
+    /** Optional storage repository UUID when resolving by name. */
+    sr_uuid?: string;
+    /** Treat a missing VDI as success when true. */
+    allow_missing?: boolean;
+}
+interface XcpngDestroyVdiResult {
+    success: boolean;
+    vdiUuid?: string;
+    command?: string;
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$r: TaskFn<XcpngDestroyVdiParams, XcpngDestroyVdiResult>;
+
+interface XcpngDestroyNetworkParams {
+    network_uuid?: string;
+    network_name_label?: string;
+    allow_missing?: boolean;
+}
+interface XcpngDestroyNetworkResult {
+    success: boolean;
+    networkUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$q: TaskFn<XcpngDestroyNetworkParams, XcpngDestroyNetworkResult>;
+
+interface XcpngDestroyTemplateParams {
+    template_uuid?: string;
+    template_name_label?: string;
+    allow_missing?: boolean;
+    force?: boolean;
+    filters?: Record<string, string | number | boolean | undefined | null>;
+}
+interface XcpngDestroyTemplateResult {
+    success: boolean;
+    templateUuid?: string;
+    command?: string;
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$p: TaskFn<XcpngDestroyTemplateParams, XcpngDestroyTemplateResult>;
+
+interface XcpngDestroyIsoSrParams {
+    /** Target SR UUID. */
+    sr_uuid?: string;
+    /** Optional SR name-label used to resolve the UUID when sr_uuid is not provided. */
+    sr_name_label?: string;
+    /** Filesystem path to remove after destroying the SR (e.g., `/var/opt/xen/iso-hostctl-e2e`). */
+    location?: string;
+    /** Treat missing SRs or paths as success when true. */
+    allow_missing?: boolean;
+}
+interface XcpngDestroyIsoSrResult {
+    success: boolean;
+    srUuid?: string;
+    commands: string[];
+    removedLocation?: boolean;
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$o: TaskFn<XcpngDestroyIsoSrParams, XcpngDestroyIsoSrResult>;
+
+interface XcpngDestroyBondParams {
+    bond_uuid?: string;
+    pif_uuid?: string;
+    allow_missing?: boolean;
+}
+interface XcpngDestroyBondResult {
+    success: boolean;
+    bondUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$n: TaskFn<XcpngDestroyBondParams, XcpngDestroyBondResult>;
+
+interface XcpngDestroySnapshotParams {
+    snapshot_uuid: string;
+}
+interface XcpngDestroySnapshotResult {
+    success: boolean;
+    snapshotUuid?: string;
+    command?: string;
+    error?: string;
+}
+declare const _default$m: TaskFn<XcpngDestroySnapshotParams, XcpngDestroySnapshotResult>;
+
+interface XcpngConvertTemplateToVmParams {
+    template_uuid?: string;
+    template_name_label?: string;
+    filters?: XcpngFindTemplateParams['filters'];
+    vm_name_label?: string;
+    description?: string;
+    allow_missing?: boolean;
+}
+interface XcpngConvertTemplateToVmResult {
+    success: boolean;
+    templateUuid?: string;
+    vmUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    alreadyVm?: boolean;
+    error?: string;
+}
+declare const _default$l: TaskFn<XcpngConvertTemplateToVmParams, XcpngConvertTemplateToVmResult>;
+
+/**
+ * Parameters for provisioning a new VM on an XCP-ng host.
+ * - `name_label`: Human-readable VM name (required).
+ * - `template_name`: Optional template name to clone (e.g., "Other install media").
+ * - `template_uuid`: Optional template UUID. Takes precedence over `template_name` when both are provided.
+ * - `description`: Optional long-form description stored on the VM record.
+ * - `affinity_host_uuid`: Optional host UUID to set VCpu affinity.
+ * - `memory_mib`: Optional memory allocation expressed in MiB. All static/dynamic bounds are set to this value.
+ * - `vcpus`: Optional number of virtual CPUs to configure.
+ */
+interface XcpngCreateVmParams {
+    name_label: string;
+    template_name?: string;
+    template_uuid?: string;
+    description?: string;
+    affinity_host_uuid?: string;
+    memory_mib?: number;
+    vcpus?: number;
+    /**
+     * Desired virtualization mode. Defaults to `pvhvm` so new guests receive hardware virtualization
+     * with PV drivers (modern XCP-ng best practice).
+     */
+    virtualization_mode?: 'pv' | 'pvhvm';
+    /**
+     * Device model to use for the guest (defaults left untouched when omitted).
+     */
+    device_model?: 'qemu_traditional' | 'qemu-upstream-compat';
+}
+/**
+ * Result payload describing the newly created VM.
+ * - `vmUuid`: Identifier emitted by `xe vm-create`.
+ * - `appliedCommands`: Ordered list of CLI invocations executed for auditing or retries.
+ * - `error`: Raw error output when any step fails.
+ */
+interface XcpngCreateVmResult {
+    success: boolean;
+    vmUuid?: string;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$k: TaskFn<XcpngCreateVmParams, XcpngCreateVmResult>;
+
+/**
+ * Parameters required to create a new virtual disk image (VDI) on an XCP-ng storage repository.
+ * - `name_label`: Human-readable name assigned to the disk.
+ * - `sr_uuid`: Identifier of the storage repository that should host the disk.
+ * - `size_bytes`/`size_mb`/`size_gb`: Provisioned size; supply exactly one (bytes, MiB, or GiB).
+ * - `description`: Optional friendly description stored alongside the VDI metadata.
+ * - `type`: Disk type (`user`, `system`, `metadata`, etc.); defaults to `user`.
+ * - `shareable`: Marks the disk as shareable across multiple VMs when set to `true`.
+ */
+interface XcpngCreateVdiParams {
+    name_label: string;
+    sr_uuid: string;
+    size_bytes?: number;
+    size_mb?: number;
+    size_gb?: number;
+    description?: string;
+    type?: string;
+    shareable?: boolean;
+}
+/**
+ * Result payload summarising the newly created disk.
+ * - `vdiUuid`: Identifier emitted by `xe vdi-create`.
+ * - `command`: Resolved CLI invocation for auditability.
+ * - `error`: Raw stderr output when the command fails.
+ */
+interface XcpngCreateVdiResult {
+    success: boolean;
+    vdiUuid?: string;
+    command?: string;
+    error?: string;
+}
+declare const _default$j: TaskFn<XcpngCreateVdiParams, XcpngCreateVdiResult>;
+
+interface XcpngCreateTemplateFromVdiParams {
+    template_name_label: string;
+    template_description?: string;
+    vm_name_label?: string;
+    vm_description?: string;
+    base_template_uuid?: string;
+    base_template_name_label?: string;
+    virtualization_mode?: 'pv' | 'pvhvm';
+    device_model?: 'qemu_traditional' | 'qemu-upstream-compat' | 'qemu-upstream-uefi';
+    memory_mib?: number;
+    vcpus?: number;
+    firmware?: 'bios' | 'uefi';
+    vdi_uuid?: string;
+    vdi_name_label?: string;
+    vdi_sr_uuid?: string;
+    disk_device?: string;
+    allow_existing_template?: boolean;
+    initial_boot_order?: string;
+    final_boot_order?: string;
+    cloud_init_user_data?: string;
+    cloud_init_user_data_b64?: string;
+    cloud_init_network_config?: string;
+    cloud_init_network_config_b64?: string;
+    cloud_init_hostname?: string;
+    cloud_init_instance_id?: string;
+}
+interface XcpngCreateTemplateFromVdiStep {
+    name: string;
+    success: boolean;
+    details?: Record<string, unknown>;
+    error?: string;
+}
+interface XcpngCreateTemplateFromVdiResult {
+    success: boolean;
+    templateUuid?: string;
+    vmUuid?: string;
+    vdiUuid?: string;
+    vbdUuid?: string;
+    appliedCommands: string[];
+    steps: XcpngCreateTemplateFromVdiStep[];
+    error?: string;
+    skipped?: boolean;
+}
+declare const _default$i: TaskFn<XcpngCreateTemplateFromVdiParams, XcpngCreateTemplateFromVdiResult>;
+
+interface XcpngCloneTemplateParams {
+    source_template_uuid?: string;
+    source_template_name_label?: string;
+    filters?: XcpngFindTemplateParams['filters'];
+    new_template_name_label: string;
+    description?: string;
+    make_default?: boolean;
+    allow_missing?: boolean;
+}
+interface XcpngCloneTemplateResult {
+    success: boolean;
+    sourceTemplateUuid?: string;
+    templateUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    alreadyExists?: boolean;
+    error?: string;
+}
+declare const _default$h: TaskFn<XcpngCloneTemplateParams, XcpngCloneTemplateResult>;
+
+interface XcpngCreateBondParams {
+    host_uuid?: string;
+    host_name_label?: string;
+    network_uuid?: string;
+    network_name_label?: string;
+    pif_uuids: string[];
+    mode?: string;
+    mtu?: number;
+    mac?: string;
+    other_config?: Record<string, string | number | boolean>;
+    properties?: Record<string, string | number | boolean>;
+}
+interface XcpngCreateBondResult {
+    success: boolean;
+    bondPifUuid?: string;
+    hostUuid?: string;
+    networkUuid?: string;
+    appliedCommands: string[];
+    error?: string;
+}
+declare const _default$g: TaskFn<XcpngCreateBondParams, XcpngCreateBondResult>;
+
+interface XcpngDetachCdMediaParams {
+    vm_uuid: string;
+    allow_missing?: boolean;
+}
+interface XcpngDetachCdMediaStep {
+    name: string;
+    success: boolean;
+    details?: Record<string, unknown>;
+    error?: string;
+}
+interface XcpngDetachCdMediaResult {
+    success: boolean;
+    vmUuid?: string;
+    removedVbds?: string[];
+    commands: string[];
+    steps: XcpngDetachCdMediaStep[];
+    error?: string;
+    skipped?: boolean;
+}
+declare const _default$f: TaskFn<XcpngDetachCdMediaParams, XcpngDetachCdMediaResult>;
+
+interface XcpngCleanupConfigDriveParams {
+    vm_uuid?: string;
+    vm_name_label?: string;
+    allow_missing?: boolean;
+    keep_vdi?: boolean;
+    require_halted?: boolean;
+}
+interface XcpngCleanupConfigDriveStep {
+    name: string;
+    success: boolean;
+    details?: Record<string, unknown>;
+    error?: string;
+}
+interface XcpngCleanupConfigDriveResult {
+    success: boolean;
+    vmUuid?: string;
+    configDriveVdis?: string[];
+    commands: string[];
+    steps: XcpngCleanupConfigDriveStep[];
+    error?: string;
+    skipped?: boolean;
+}
+declare const _default$e: TaskFn<XcpngCleanupConfigDriveParams, XcpngCleanupConfigDriveResult>;
+
+interface XcpngCreateConfigDriveParams {
+    iso_sr_uuid?: string;
+    iso_sr_name_label?: string;
+    iso_sr_location?: string;
+    iso_sr_location_owner?: string;
+    iso_sr_location_mode?: string;
+    iso_filename?: string;
+    overwrite?: boolean;
+    volume_id?: string;
+    iso_tool_name?: string;
+    vm_uuid?: string;
+    vm_name_label?: string;
+    instance_id?: string;
+    hostname?: string;
+    user_data?: string;
+    user_data_b64?: string;
+    meta_data?: string;
+    meta_data_b64?: string;
+    network_config?: string;
+    network_config_b64?: string;
+    local_iso_path?: string;
+}
+interface XcpngCreateConfigDriveStep {
+    name: string;
+    success: boolean;
+    details?: Record<string, unknown>;
+    error?: string;
+}
+interface XcpngCreateConfigDriveResult {
+    success: boolean;
+    srUuid?: string;
+    vdiUuid?: string;
+    isoPath?: string;
+    volumeId?: string;
+    reused?: boolean;
+    commands: string[];
+    steps: XcpngCreateConfigDriveStep[];
+    error?: string;
+}
+declare const _default$d: TaskFn<XcpngCreateConfigDriveParams, XcpngCreateConfigDriveResult>;
+
+interface XcpngCreateNetworkParams {
+    name_label: string;
+    description?: string;
+    bridge?: string;
+    mtu?: number;
+    tags?: string[];
+    allow_existing?: boolean;
+}
+interface XcpngCreateNetworkResult {
+    success: boolean;
+    networkUuid?: string;
+    appliedCommands: string[];
+    skipped?: boolean;
+    error?: string;
+}
+declare const _default$c: TaskFn<XcpngCreateNetworkParams, XcpngCreateNetworkResult>;
+
+interface XcpngCreateTemplateParams {
+    source_vm_uuid?: string;
+    source_vm_name_label?: string;
+    template_name_label: string;
+    description?: string;
+    make_default?: boolean;
+}
+interface XcpngCreateTemplateResult {
+    success: boolean;
+    sourceVmUuid?: string;
+    templateUuid?: string;
+    appliedCommands: string[];
+    error?: string;
+    powerState?: string;
+    waitAttempts?: number;
+}
+declare const _default$b: TaskFn<XcpngCreateTemplateParams, XcpngCreateTemplateResult>;
+
+/**
+ * Parameters for attaching an existing virtual disk image to a VM.
+ * - `vm_uuid`: Target VM identifier.
+ * - `vdi_uuid`: Disk identifier returned by `xe vdi-create` or `xe vdi-list`.
+ * - `device`: Virtual device slot (e.g., `0`, `1`). Defaults to `0`.
+ * - `mode`: Access mode (`RW` or `RO`). Defaults to `RW`.
+ * - `bootable`: Marks the disk as bootable if `true`.
+ */
+interface XcpngAttachVdiParams {
+    vm_uuid: string;
+    vdi_uuid: string;
+    device?: string;
+    mode?: 'RW' | 'RO';
+    bootable?: boolean;
+}
+/**
+ * Result summarising the new virtual block device (VBD) created for the VM.
+ * - `vbdUuid`: Identifier emitted by `xe vbd-create`.
+ * - `appliedCommands`: Both creation and plug commands for auditing purposes.
+ * - `error`: Raw stderr output when the workflow fails.
+ */
+interface XcpngAttachVdiResult {
+    success: boolean;
+    vbdUuid?: string;
+    appliedCommands: string[];
+    plugged?: boolean;
+    error?: string;
+}
+declare const _default$a: TaskFn<XcpngAttachVdiParams, XcpngAttachVdiResult>;
+
+/**
+ * Parameters for attaching a virtual network interface (VIF) to a VM.
+ * - `vm_uuid`: Target VM identifier.
+ * - `network_uuid`: Network resource UUID obtained from `xe network-list`.
+ * - `device`: Optional slot number (defaults to `0`).
+ * - `mac_address`: Optional static MAC address. Leave undefined to let XCP-ng assign one.
+ * - `mtu`: Optional MTU value applied to the interface.
+ */
+interface XcpngAttachNetworkInterfaceParams {
+    vm_uuid: string;
+    network_uuid: string;
+    device?: string;
+    mac_address?: string;
+    mtu?: number;
+}
+/**
+ * Result details for the newly created VIF.
+ * - `vifUuid`: Identifier emitted by `xe vif-create`.
+ * - `appliedCommands`: Creation and plug commands executed in order.
+ * - `error`: Raw stderr output when the workflow fails.
+ */
+interface XcpngAttachNetworkInterfaceResult {
+    success: boolean;
+    vifUuid?: string;
+    appliedCommands: string[];
+    plugged?: boolean;
+    error?: string;
+}
+declare const _default$9: TaskFn<XcpngAttachNetworkInterfaceParams, XcpngAttachNetworkInterfaceResult>;
+
+/**
+ * Parameters for inserting an ISO image into a VM's virtual CD drive.
+ * - `vm_uuid`: Target VM identifier.
+ * - `iso_vdi_uuid`: UUID of the ISO VDI stored in an SR.
+ * - `device`: Optional CD device slot (defaults to hypervisor choice, commonly `3`).
+ * - `eject_before_insert`: Attempts to eject any existing media before inserting the new ISO.
+ */
+interface XcpngAttachIsoParams {
+    vm_uuid: string;
+    iso_vdi_uuid: string;
+    device?: string;
+    eject_before_insert?: boolean;
+}
+/**
+ * Result describing the CD handling workflow.
+ * - `appliedCommands`: Ordered list of `xe` commands executed.
+ * - `error`: Raw stderr output when the insert workflow fails.
+ */
+interface XcpngAttachIsoResult {
+    success: boolean;
+    appliedCommands: string[];
+    plugged?: boolean;
+    error?: string;
+}
+declare const _default$8: TaskFn<XcpngAttachIsoParams, XcpngAttachIsoResult>;
+
+interface XcpngAddDiskParams {
+    vm_uuid: string;
+    sr_uuid?: string;
+    sr_name_label?: string;
+    /** Provide exactly one of the size fields to set disk capacity. */
+    size_bytes?: number;
+    size_mb?: number;
+    size_gb?: number;
+    size_mib?: number;
+    name_label?: string;
+    description?: string;
+    device?: string;
+    mode?: 'RW' | 'RO';
+    bootable?: boolean;
+    shareable?: boolean;
+    type?: string;
+    cleanup_vdi_on_failure?: boolean;
+}
+interface XcpngAddDiskResult {
+    success: boolean;
+    vmUuid?: string;
+    vdiUuid?: string;
+    vbdUuid?: string;
+    appliedCommands: string[];
+    plugged?: boolean;
+    error?: string;
+}
+declare const _default$7: TaskFn<XcpngAddDiskParams, XcpngAddDiskResult>;
+
+declare const _default$6: {
+    addDisk: TaskFn<XcpngAddDiskParams, XcpngAddDiskResult>;
+    attachIso: TaskFn<XcpngAttachIsoParams, XcpngAttachIsoResult>;
+    attachNetworkInterface: TaskFn<XcpngAttachNetworkInterfaceParams, XcpngAttachNetworkInterfaceResult>;
+    attachVdi: TaskFn<XcpngAttachVdiParams, XcpngAttachVdiResult>;
+    createTemplate: TaskFn<XcpngCreateTemplateParams, XcpngCreateTemplateResult>;
+    createNetwork: TaskFn<XcpngCreateNetworkParams, XcpngCreateNetworkResult>;
+    createConfigDrive: TaskFn<XcpngCreateConfigDriveParams, XcpngCreateConfigDriveResult>;
+    cleanupConfigDrive: TaskFn<XcpngCleanupConfigDriveParams, XcpngCleanupConfigDriveResult>;
+    detachCdMedia: TaskFn<XcpngDetachCdMediaParams, XcpngDetachCdMediaResult>;
+    createBond: TaskFn<XcpngCreateBondParams, XcpngCreateBondResult>;
+    cloneTemplate: TaskFn<XcpngCloneTemplateParams, XcpngCloneTemplateResult>;
+    createTemplateFromVdi: TaskFn<XcpngCreateTemplateFromVdiParams, XcpngCreateTemplateFromVdiResult>;
+    createVdi: TaskFn<XcpngCreateVdiParams, XcpngCreateVdiResult>;
+    createVm: TaskFn<XcpngCreateVmParams, XcpngCreateVmResult>;
+    convertTemplateToVm: TaskFn<XcpngConvertTemplateToVmParams, XcpngConvertTemplateToVmResult>;
+    destroySnapshot: TaskFn<XcpngDestroySnapshotParams, XcpngDestroySnapshotResult>;
+    destroyBond: TaskFn<XcpngDestroyBondParams, XcpngDestroyBondResult>;
+    destroyIsoSr: TaskFn<XcpngDestroyIsoSrParams, XcpngDestroyIsoSrResult>;
+    destroyTemplate: TaskFn<XcpngDestroyTemplateParams, XcpngDestroyTemplateResult>;
+    destroyNetwork: TaskFn<XcpngDestroyNetworkParams, XcpngDestroyNetworkResult>;
+    destroyVdi: TaskFn<XcpngDestroyVdiParams, XcpngDestroyVdiResult>;
+    destroyVm: TaskFn<XcpngDestroyVmParams, XcpngDestroyVmResult>;
+    copyVdi: TaskFn<XcpngCopyVdiParams, XcpngCopyVdiResult>;
+    exportVdi: TaskFn<XcpngExportVdiParams, XcpngExportVdiResult>;
+    vmCopy: TaskFn<XcpngVmCopyParams, XcpngVmCopyResult>;
+    vmMigrate: TaskFn<XcpngVmMigrateParams, XcpngVmMigrateResult>;
+    vmExport: TaskFn<XcpngVmExportParams, XcpngVmExportResult>;
+    vmImport: TaskFn<XcpngVmImportParams, XcpngVmImportResult>;
+    detachIso: TaskFn<XcpngDetachIsoParams, XcpngDetachIsoResult>;
+    detachNetworkInterface: TaskFn<XcpngDetachNetworkInterfaceParams, XcpngDetachNetworkInterfaceResult>;
+    detachVdi: TaskFn<XcpngDetachVdiParams, XcpngDetachVdiResult>;
+    createSr: TaskFn<XcpngCreateSrParams, XcpngCreateSrResult>;
+    destroySr: TaskFn<XcpngDestroySrParams, XcpngDestroySrResult>;
+    introduceSr: TaskFn<XcpngIntroduceSrParams, XcpngIntroduceSrResult>;
+    forgetSr: TaskFn<XcpngForgetSrParams, XcpngForgetSrResult>;
+    listSnapshots: TaskFn<XcpngListSnapshotsParams, XcpngListSnapshotsResult>;
+    listMessages: TaskFn<XcpngListMessagesParams, XcpngListMessagesResult>;
+    clearMessages: TaskFn<XcpngClearMessagesParams, XcpngClearMessagesResult>;
+    listHosts: TaskFn<XcpngListHostsParams, XcpngListHostsResult>;
+    findHost: TaskFn<XcpngFindHostParams, XcpngFindHostResult>;
+    enableHost: TaskFn<XcpngEnableHostParams, XcpngEnableHostResult>;
+    disableHost: TaskFn<XcpngDisableHostParams, XcpngDisableHostResult>;
+    rebootHost: TaskFn<XcpngRebootHostParams, XcpngRebootHostResult>;
+    shutdownHost: TaskFn<XcpngShutdownHostParams, XcpngShutdownHostResult>;
+    evacuateHost: TaskFn<XcpngEvacuateHostParams, XcpngEvacuateHostResult>;
+    listPbds: TaskFn<XcpngListPbdsParams, XcpngListPbdsResult>;
+    findPbd: TaskFn<XcpngFindPbdParams, XcpngFindPbdResult>;
+    createPbd: TaskFn<XcpngCreatePbdParams, XcpngCreatePbdResult>;
+    destroyPbd: TaskFn<XcpngDestroyPbdParams, XcpngDestroyPbdResult>;
+    plugPbd: TaskFn<XcpngPlugPbdParams, XcpngPlugPbdResult>;
+    unplugPbd: TaskFn<XcpngUnplugPbdParams, XcpngUnplugPbdResult>;
+    listPools: TaskFn<XcpngListPoolsParams, XcpngListPoolsResult>;
+    findPool: TaskFn<XcpngFindPoolParams, XcpngFindPoolResult>;
+    setPoolParam: TaskFn<XcpngSetPoolParamParams, XcpngSetPoolParamResult>;
+    setNetworkParam: TaskFn<XcpngSetNetworkParamParams, XcpngSetNetworkParamResult>;
+    setSrParam: TaskFn<XcpngSetSrParamParams, XcpngSetSrParamResult>;
+    plugPif: TaskFn<XcpngPlugPifParams, XcpngPlugPifResult>;
+    pifScan: TaskFn<XcpngPifScanParams, XcpngPifScanResult>;
+    unplugPif: TaskFn<XcpngUnplugPifParams, XcpngUnplugPifResult>;
+    setPifParam: TaskFn<XcpngSetPifParamParams, XcpngSetPifParamResult>;
+    rebootVm: TaskFn<XcpngRebootVmParams, XcpngRebootVmResult>;
+    findTemplate: TaskFn<XcpngFindTemplateParams, XcpngFindTemplateResult>;
+    findVdi: TaskFn<XcpngFindVdiParams, XcpngFindVdiResult>;
+    findVm: TaskFn<XcpngFindVmParams, XcpngFindVmResult>;
+    findOrCreateIsoSr: TaskFn<XcpngFindOrCreateIsoSrParams, XcpngFindOrCreateIsoSrResult>;
+    findStorageRepository: TaskFn<XcpngFindStorageRepositoryParams, XcpngFindStorageRepositoryResult>;
+    findNetwork: TaskFn<XcpngFindNetworkParams, XcpngFindNetworkResult>;
+    importIso: TaskFn<XcpngImportIsoParams, XcpngImportIsoResult>;
+    provisionVmFromIso: TaskFn<XcpngProvisionVmFromIsoParams, XcpngProvisionVmFromIsoResult>;
+    provisionVm: TaskFn<XcpngProvisionVmParams, XcpngProvisionVmResult>;
+    uploadIso: TaskFn<XcpngUploadIsoParams, XcpngUploadIsoResult>;
+    listStorageRepositories: TaskFn<XcpngListStorageRepositoriesParams, XcpngListStorageRepositoriesResult>;
+    listNetworks: TaskFn<XcpngListNetworksParams, XcpngListNetworksResult>;
+    listTemplates: TaskFn<XcpngListTemplatesParams, XcpngListTemplatesResult>;
+    listVbds: TaskFn<XcpngListVbdsParams, XcpngListVbdsResult>;
+    listVifs: TaskFn<XcpngListVifsParams, XcpngListVifsResult>;
+    listPifs: TaskFn<XcpngListPifsParams, XcpngListPifsResult>;
+    listVdis: TaskFn<XcpngListVdisParams, XcpngListVdisResult>;
+    importVdi: TaskFn<XcpngImportVdiParams, XcpngImportVdiResult>;
+    listVms: TaskFn<XcpngListVmsParams, XcpngListVmsResult>;
+    resizeVdi: TaskFn<XcpngResizeVdiParams, XcpngResizeVdiResult>;
+    resizeVmCpus: TaskFn<XcpngResizeVmCpusParams, XcpngResizeVmCpusResult>;
+    resizeVmMemory: TaskFn<XcpngResizeVmMemoryParams, XcpngResizeVmMemoryResult>;
+    removeDisk: TaskFn<XcpngRemoveDiskParams, XcpngRemoveDiskResult>;
+    revertSnapshot: TaskFn<XcpngRevertSnapshotParams, XcpngRevertSnapshotResult>;
+    setSnapshotParam: TaskFn<XcpngSetSnapshotParamParams, XcpngSetSnapshotParamResult>;
+    setBootOrder: TaskFn<XcpngSetBootOrderParams, XcpngSetBootOrderResult>;
+    setVmResources: TaskFn<XcpngSetVmResourcesParams, XcpngSetVmResourcesResult>;
+    suspendVm: TaskFn<XcpngSuspendVmParams, XcpngSuspendVmResult>;
+    resumeVm: TaskFn<XcpngResumeVmParams, XcpngResumeVmResult>;
+    unplugVbd: TaskFn<XcpngUnplugVbdParams, XcpngUnplugVbdResult>;
+    snapshotVm: TaskFn<XcpngSnapshotVmParams, XcpngSnapshotVmResult>;
+    startVm: TaskFn<XcpngStartVmParams, XcpngStartVmResult>;
+    stopVm: TaskFn<XcpngStopVmParams, XcpngStopVmResult>;
+    getVmInfo: TaskFn<XcpngGetVmInfoParams, XcpngGetVmInfoResult>;
+    listAttachedDisks: TaskFn<XcpngListAttachedDisksParams, XcpngListAttachedDisksResult>;
+};
+
+declare namespace xcpng {
+  export { _default$7 as addDisk, _default$8 as attachIso, _default$9 as attachNetworkInterface, _default$a as attachVdi, _default$e as cleanupConfigDrive, _default$I as clearMessages, _default$h as cloneTemplate, _default$l as convertTemplateToVm, _default$t as copyVdi, _default$g as createBond, _default$d as createConfigDrive, _default$c as createNetwork, _default$S as createPbd, _default$C as createSr, _default$b as createTemplate, _default$i as createTemplateFromVdi, _default$j as createVdi, _default$k as createVm, _default$6 as default, _default$n as destroyBond, _default$o as destroyIsoSr, _default$q as destroyNetwork, _default$T as destroyPbd, _default$m as destroySnapshot, _default$D as destroySr, _default$p as destroyTemplate, _default$r as destroyVdi, _default$s as destroyVm, _default$f as detachCdMedia, _default$z as detachIso, _default$A as detachNetworkInterface, _default$B as detachVdi, _default$M as disableHost, _default$L as enableHost, _default$P as evacuateHost, _default$u as exportVdi, _default$J as findHost, _default$19 as findNetwork, _default$17 as findOrCreateIsoSr, _default$Q as findPbd, _default$W as findPool, _default$18 as findStorageRepository, _default$14 as findTemplate, _default$15 as findVdi, _default$16 as findVm, _default$F as forgetSr, _default$1z as getVmInfo, _default$1a as importIso, _default$1j as importVdi, _default$E as introduceSr, _default$1C as listAttachedDisks, _default$K as listHosts, _default$H as listMessages, _default$1f as listNetworks, _default$R as listPbds, _default$1h as listPifs, _default$X as listPools, _default$G as listSnapshots, _default$1e as listStorageRepositories, _default$1g as listTemplates, _default$1B as listVbds, _default$1i as listVdis, _default$1A as listVifs, _default$1k as listVms, _default$10 as pifScan, _default$U as plugPbd, _default$$ as plugPif, _default$1c as provisionVm, _default$1b as provisionVmFromIso, _default$N as rebootHost, _default$13 as rebootVm, _default$1o as removeDisk, _default$1l as resizeVdi, _default$1m as resizeVmCpus, _default$1n as resizeVmMemory, _default$1u as resumeVm, _default$1p as revertSnapshot, _default$1r as setBootOrder, _default$Z as setNetworkParam, _default$12 as setPifParam, _default$Y as setPoolParam, _default$1q as setSnapshotParam, _default$_ as setSrParam, _default$1s as setVmResources, _default$O as shutdownHost, _default$1w as snapshotVm, _default$1x as startVm, _default$1y as stopVm, _default$1t as suspendVm, _default$V as unplugPbd, _default$11 as unplugPif, _default$1v as unplugVbd, _default$1d as uploadIso, _default$v as vmCopy, _default$x as vmExport, _default$y as vmImport, _default$w as vmMigrate };
+}
+
+interface YumAddRepositoryParams {
+    content: string;
+    name: string;
+    /** Run commands with sudo (default true) */
+    sudo?: boolean;
+}
+interface YumAddRepositoryResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$5: TaskFn<YumAddRepositoryParams, YumAddRepositoryResult>;
+
+declare namespace yum {
+  export { _default$5 as add_repository };
+}
+
+interface DownloadParams {
+    url: string;
+    dest: string;
+    mode?: string | number;
+    /** Run commands with sudo (default false) */
+    sudo?: boolean;
+}
+interface DownloadResult {
+    success: boolean;
+    path?: string;
+    error?: string;
+}
+declare const _default$4: TaskFn<DownloadParams, DownloadResult>;
+
+interface NetworkInterface {
+    name: string;
+    state: string;
+    mac?: string;
+    ipv4?: {
+        address: string;
+        prefix: number;
+    };
+    ipv6?: {
+        address: string;
+        prefix: number;
+    };
+    ipv4_addresses?: Array<{
+        address: string;
+        prefix: number;
+    }>;
+    ipv6_addresses?: Array<{
+        address: string;
+        prefix: number;
+    }>;
+    mtu?: string;
+    type?: string;
+}
+interface InterfacesParams {
+    /** Run commands with sudo (default false) */
+    sudo?: boolean;
+}
+interface InterfacesResult {
+    success: boolean;
+    interfaces?: NetworkInterface[];
+    error?: string;
+}
+declare const _default$3: TaskFn<InterfacesParams, InterfacesResult>;
+
+declare namespace net {
+  export { _default$4 as download, _default$3 as interfaces };
+}
+
+interface NftablesApplyParams {
+    config: string;
+}
+interface NftablesApplyResult {
+    success: boolean;
+    error?: string;
+}
+
+declare const _default$2: {
+    apply: TaskFn<NftablesApplyParams, NftablesApplyResult>;
+};
+
+declare namespace nftables {
+  export { _default$2 as default };
+}
+
+interface FirewalldDisableResult {
+    success: boolean;
+    error?: string;
+}
+
+declare const _default$1: {
+    disable: TaskFn<ObjectType, FirewalldDisableResult>;
+};
+
+declare namespace firewalld {
+  export { _default$1 as default };
+}
+
+declare const _default: {
+    echo: TaskFn<EchoParams, EchoResult>;
+    env: TaskFn<EnvParams, EnvResult>;
+    whoami: TaskFn<WhoamiParams, WhoamiResult>;
+    dir: typeof dir;
+    file: typeof file;
+    git: typeof git;
+    group: typeof group;
+    host: typeof host;
+    pkg: typeof pkg;
+    k3s: typeof k3s;
+    docker: typeof docker;
+    ssh: typeof ssh;
+    sudoers: typeof sudoers;
+    process: typeof process;
+    system: typeof system;
+    systemd: typeof systemd;
+    template: typeof template;
+    ufw: typeof ufw;
+    user: typeof user;
+    xcpng: typeof xcpng;
+    apt: typeof index$3;
+    yum: typeof yum;
+    net: typeof net;
+    nftables: typeof nftables;
+    firewalld: typeof firewalld;
+};
+
+declare class RemoteRuntime implements IRuntime {
+    private sftpClientInstance?;
+    readonly app: App;
+    readonly host: Host;
+    readonly interactionHandler: InteractionHandler;
+    private sshSession;
+    constructor(app: App, host: Host, interactionHandler?: InteractionHandler);
+    get tmpDirRootPath(): Path;
+    getPassword(): Promise<string | undefined>;
+    getSecret(name: string): Promise<string | undefined>;
+    getTmpDir(): Path;
+    getTmpFile(prefix?: string | undefined, postfix?: string | undefined, dir?: Path | undefined): Path;
+    inventory(tags: string[]): Host[];
+    selectedInventory(tags?: string[]): Host[];
+    connect(): Promise<boolean>;
+    getSftpClient(): Promise<any>;
+    executeCommand(command: Command, options?: {
+        stdin?: string | Buffer;
+        pty?: boolean;
+        interactionHandler?: InteractionHandler;
+    }): Promise<Command | Error>;
+    disconnect(): Promise<void>;
+    invokeRootTask<TParams extends TaskParams, TReturn extends RunFnReturnValue>(taskFnDefinition: TaskFn<TParams, TReturn>, params: TParams): Promise<IInvocation>;
+}
 
-export { App, CHECKMARK, type ChgrpParams, type ChgrpResult, type ChmodParams, type ChmodResult, type ChownParams, type ChownResult, Cli, CommandResult, type EnvVarObj, type FileSystemOperations$1 as FileSystemOperations, Host, type IInvocation, type IRuntime, type InputMap, Invocation, LocalRuntime, type LogLevel, type ObjectType, type OsDetailsResult, type PkgInfoParams, type PkgInfoResult, type PkgInstallParams, type PkgInstallResult, type PkgIsInstalledParams, type PkgIsInstalledResult, type PkgRemoveParams, type PkgRemoveResult, type PkgUpdateParams, type PkgUpdateResult, type RebootIfNeededParams, type RebootIfNeededResult, type RebootNeededParams, type RebootNeededResult, type RebootParams, type RebootResult, RemoteRuntime, type RunFn, type RunFnReturnValue, SUDO_PROMPT_REGEX, type ShutdownParams, type ShutdownResult, Task, type TaskContext, type TaskFn, type TaskParams, type TaskPartialFn, Verbosity, XMARK, _default as core, task, withSudo };
+export { type AddUsersParams, type AddUsersResult, App, CHECKMARK, type ChgrpParams, type ChgrpResult, type ChmodParams, type ChmodResult, type ChownParams, type ChownResult, Cli, CommandResult, type DockerInstallParams, type DockerInstallResult, type EnvVarObj, type ExecuteResult, type FileSystemOperations$1 as FileSystemOperations, Host, type IInvocation, type IRuntime, type InputMap, type InstallComposeParams, type InstallComposeResult, Invocation, LocalRuntime, type LogLevel, type ObjectType, type OsDetailsResult, type PkgInfoParams, type PkgInfoResult, type PkgInstallParams, type PkgInstallResult, type PkgIsInstalledParams, type PkgIsInstalledResult, type PkgRemoveParams, type PkgRemoveResult, type PkgUpdateParams, type PkgUpdateResult, type RebootIfNeededParams, type RebootIfNeededResult, type RebootNeededParams, type RebootNeededResult, type RebootParams, type RebootResult, RemoteRuntime, type RunFn, type RunFnReturnValue, SUDO_PROMPT_REGEX, type ShutdownParams, type ShutdownResult, Task, type TaskContext, type TaskFn, type TaskParams, type TaskPartialFn, Verbosity, XMARK, type XcpngAddDiskParams, type XcpngAddDiskResult, type XcpngAttachIsoParams, type XcpngAttachIsoResult, type XcpngAttachNetworkInterfaceParams, type XcpngAttachNetworkInterfaceResult, type XcpngAttachVdiParams, type XcpngAttachVdiResult, type XcpngAttachedDisk, type XcpngCleanupConfigDriveParams, type XcpngCleanupConfigDriveResult, type XcpngCleanupConfigDriveStep, type XcpngClearMessagesParams, type XcpngClearMessagesResult, type XcpngCloneTemplateParams, type XcpngCloneTemplateResult, type XcpngConvertTemplateToVmParams, type XcpngConvertTemplateToVmResult, type XcpngCopyVdiParams, type XcpngCopyVdiResult, type XcpngCreateBondParams, type XcpngCreateBondResult, type XcpngCreateConfigDriveParams, type XcpngCreateConfigDriveResult, type XcpngCreateConfigDriveStep, type XcpngCreatePbdParams, type XcpngCreatePbdResult, type XcpngCreateSrParams, type XcpngCreateSrResult, type XcpngCreateTemplateFromVdiParams, type XcpngCreateTemplateFromVdiResult, type XcpngCreateTemplateFromVdiStep, type XcpngCreateTemplateParams, type XcpngCreateTemplateResult, type XcpngCreateVdiParams, type XcpngCreateVdiResult, type XcpngCreateVmParams, type XcpngCreateVmResult, type XcpngDestroyBondParams, type XcpngDestroyBondResult, type XcpngDestroyIsoSrParams, type XcpngDestroyIsoSrResult, type XcpngDestroyPbdParams, type XcpngDestroyPbdResult, type XcpngDestroySnapshotParams, type XcpngDestroySnapshotResult, type XcpngDestroySrParams, type XcpngDestroySrResult, type XcpngDestroyTemplateParams, type XcpngDestroyTemplateResult, type XcpngDestroyVdiParams, type XcpngDestroyVdiResult, type XcpngDestroyVmParams, type XcpngDestroyVmResult, type XcpngDetachCdMediaParams, type XcpngDetachCdMediaResult, type XcpngDetachCdMediaStep, type XcpngDetachIsoParams, type XcpngDetachIsoResult, type XcpngDetachNetworkInterfaceParams, type XcpngDetachNetworkInterfaceResult, type XcpngDetachVdiParams, type XcpngDetachVdiResult, type XcpngDisableHostParams, type XcpngDisableHostResult, type XcpngEnableHostParams, type XcpngEnableHostResult, type XcpngExportVdiParams, type XcpngExportVdiResult, type XcpngFindHostParams, type XcpngFindHostResult, type XcpngFindNetworkParams, type XcpngFindNetworkResult, type XcpngFindOrCreateIsoSrParams, type XcpngFindOrCreateIsoSrResult, type XcpngFindPbdParams, type XcpngFindPbdResult, type XcpngFindPoolParams, type XcpngFindPoolResult, type XcpngFindStorageRepositoryParams, type XcpngFindStorageRepositoryResult, type XcpngFindTemplateParams, type XcpngFindTemplateResult, type XcpngFindVdiParams, type XcpngFindVdiResult, type XcpngFindVmParams, type XcpngFindVmResult, type XcpngForgetSrParams, type XcpngForgetSrResult, type XcpngGetVmInfoParams, type XcpngGetVmInfoResult, type XcpngImportIsoParams, type XcpngImportIsoResult, type XcpngImportVdiParams, type XcpngImportVdiResult, type XcpngIntroduceSrParams, type XcpngIntroduceSrResult, type XcpngListAttachedDisksParams, type XcpngListAttachedDisksResult, type XcpngListHostsParams, type XcpngListHostsResult, type XcpngListMessagesParams, type XcpngListMessagesResult, type XcpngListNetworksParams, type XcpngListNetworksResult, type XcpngListPbdsParams, type XcpngListPbdsResult, type XcpngListPoolsParams, type XcpngListPoolsResult, type XcpngListSnapshotsParams, type XcpngListSnapshotsResult, type XcpngListStorageRepositoriesParams, type XcpngListStorageRepositoriesResult, type XcpngListTemplatesParams, type XcpngListTemplatesResult, type XcpngListVbdsParams, type XcpngListVbdsResult, type XcpngListVdisParams, type XcpngListVdisResult, type XcpngListVmsParams, type XcpngListVmsResult, type XcpngPifScanParams, type XcpngPifScanResult, type XcpngPlugPbdParams, type XcpngPlugPbdResult, type XcpngPlugPifParams, type XcpngPlugPifResult, type XcpngProvisionVmFromIsoParams, type XcpngProvisionVmFromIsoResult, type XcpngProvisionVmFromIsoStep, type XcpngProvisionVmParams, type XcpngProvisionVmResult, type XcpngProvisionVmStep, type XcpngRebootVmParams, type XcpngRebootVmResult, type XcpngRemoveDiskParams, type XcpngRemoveDiskResult, type XcpngResizeVdiParams, type XcpngResizeVdiResult, type XcpngResizeVmCpusParams, type XcpngResizeVmCpusResult, type XcpngResizeVmMemoryParams, type XcpngResizeVmMemoryResult, type XcpngResumeVmParams, type XcpngResumeVmResult, type XcpngRevertSnapshotParams, type XcpngRevertSnapshotResult, type XcpngSetBootOrderParams, type XcpngSetBootOrderResult, type XcpngSetNetworkParamParams, type XcpngSetNetworkParamResult, type XcpngSetPifParamParams, type XcpngSetPifParamResult, type XcpngSetPoolParamParams, type XcpngSetPoolParamResult, type XcpngSetSnapshotParamParams, type XcpngSetSnapshotParamResult, type XcpngSetSrParamParams, type XcpngSetSrParamResult, type XcpngSetVmResourcesParams, type XcpngSetVmResourcesResult, type XcpngSnapshotVmParams, type XcpngSnapshotVmResult, type XcpngStartVmParams, type XcpngStartVmResult, type XcpngStopVmParams, type XcpngStopVmResult, type XcpngSuspendVmParams, type XcpngSuspendVmResult, type XcpngUnplugPbdParams, type XcpngUnplugPbdResult, type XcpngUnplugPifParams, type XcpngUnplugPifResult, type XcpngUnplugVbdParams, type XcpngUnplugVbdResult, type XcpngUploadIsoHostResult, type XcpngUploadIsoParams, type XcpngUploadIsoResult, type XcpngVmCopyParams, type XcpngVmCopyResult, type XcpngVmExportParams, type XcpngVmExportResult, type XcpngVmImportParams, type XcpngVmImportResult, type XcpngVmInfo, type XcpngVmMigrateParams, type XcpngVmMigrateResult, _default as core, task, withSudo };