@dockstat/docker 0.1.0 → 0.1.2

package/dist/types.d.ts

@@ -0,0 +1,2442 @@
+declare module "modules/base/types" {
+    import type { TLSOptions } from "bun";
+    export type ConnectionMode = "unix" | "tcp";
+    export interface ConnectionConfig {
+        mode: ConnectionMode;
+        socketPath?: string;
+        baseUrl?: string;
+        tls?: TLSOptions;
+        dockerAPIVersion?: string;
+    }
+    export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "HEAD";
+}
+declare module "utils/request-options" {
+    import type { BodyInit, HeadersInit } from "bun";
+    import type { ConnectionConfig, HttpMethod } from "modules/base/types";
+    export function prepareRequestOptions(config: ConnectionConfig, method: HttpMethod, body?: BodyInit | object, headers?: HeadersInit, url?: string): BunFetchRequestInit;
+}
+declare module "utils/error" {
+    export class DockerError extends Error {
+        status: number;
+        path: string;
+        version: string;
+        params: object | string;
+        constructor(message: string, status: number, path: string, version: string, params: object | string);
+    }
+}
+declare module "utils/response" {
+    export function handleDockerResponse(response: Response, path: string, apiVersion: string, params: object | undefined): Promise<Response>;
+}
+declare module "utils/url" {
+    import type { ConnectionConfig } from "modules/base/types";
+    /**
+     * Converts an object of parameters into a URL query string.
+     * Handles strings, numbers, booleans, and JSON serializable objects.
+     */
+    export function buildQueryString(params?: object): string | undefined;
+    /**
+     * Constructs the full request URL based on the connection mode (Unix/Http) and API version.
+     */
+    export function buildDockerUrl(config: ConnectionConfig, path: string, query: string | undefined, apiVersion: string): string;
+}
+declare module "modules/_socket/index" {
+    /**
+     * WebSocket-like interface for Docker container attach
+     * Uses the attach endpoint with stream wrapping for compatibility with Unix sockets
+     *
+     * @note Currently supports read-only operations (receiving stdout/stderr). Full WebSocket
+     * protocol support with bidirectional communication is planned for future versions.
+     */
+    export class DockerWebSocket {
+        private static readonly CONNECTING;
+        private static readonly OPEN;
+        private static readonly CLOSING;
+        private static readonly CLOSED;
+        private readyStateValue;
+        private listeners;
+        private reader;
+        addEventListener(type: string, listener: (event: unknown) => void): void;
+        removeEventListener(type: string, listener: (event: unknown) => void): void;
+        attach(response: Response): Promise<void>;
+        close(): void;
+        get CONNECTING(): number;
+        get OPEN(): number;
+        get CLOSING(): number;
+        get CLOSED(): number;
+        get readyState(): number;
+        private emit;
+    }
+}
+declare module "modules/base/index" {
+    import type { BodyInit, HeadersInit } from "bun";
+    import { DockerWebSocket } from "modules/_socket/index";
+    import type { ConnectionConfig, HttpMethod } from "modules/base/types";
+    export class BaseModule {
+        private config;
+        constructor(config: ConnectionConfig);
+        protected ws: DockerWebSocket;
+        request(path: string, method?: HttpMethod, body?: BodyInit | object, headers?: HeadersInit, params?: object): Promise<Response>;
+    }
+}
+declare module "modules/container/types" {
+    /**
+     * Container summary information
+     */
+    export interface ContainerSummary {
+        Id: string;
+        Names: string[];
+        Image: string;
+        ImageID: string;
+        Command: string;
+        Created: number;
+        Ports: Port[];
+        SizeRw?: number;
+        SizeRootFs?: number;
+        Labels?: Record<string, string>;
+        State: string;
+        Status: string;
+        HostConfig?: {
+            NetworkMode: string;
+            Annotations?: Record<string, string>;
+        };
+        NetworkSettings?: {
+            Networks?: Record<string, NetworkSummary>;
+        };
+        Mounts?: Mount[];
+        Health?: Health;
+    }
+    /**
+     * Detailed container information
+     */
+    export interface ContainerInspectResponse {
+        Id: string;
+        Created: string;
+        Path: string;
+        Args: string[];
+        State: ContainerState;
+        Image: string;
+        ResolvConfPath: string;
+        HostnamePath: string;
+        HostsPath: string;
+        LogPath: string;
+        Name: string;
+        RestartCount: number;
+        Driver: string;
+        Platform: string;
+        MountLabel: string;
+        ProcessLabel: string;
+        AppArmorProfile: string;
+        ExecIDs: string[];
+        HostConfig: HostConfig;
+        GraphDriver: GraphDriver;
+        SizeRw?: number;
+        SizeRootFs?: number;
+        Mounts?: Mount[];
+        Config: ContainerConfig;
+        NetworkSettings: NetworkSettings;
+    }
+    /**
+     * Container state information
+     */
+    export interface ContainerState {
+        Status: string;
+        Running: boolean;
+        Paused: boolean;
+        Restarting: boolean;
+        OOMKilled: boolean;
+        Dead: boolean;
+        Pid?: number;
+        ExitCode?: number;
+        Error?: string;
+        StartedAt?: string;
+        FinishedAt?: string;
+        Health?: Health;
+    }
+    /**
+     * Container configuration
+     */
+    export interface ContainerConfig {
+        Hostname: string;
+        Domainname: string;
+        User?: string;
+        AttachStdin: boolean;
+        AttachStdout: boolean;
+        AttachStderr: boolean;
+        ExposedPorts?: Record<string, object> | null;
+        Tty: boolean;
+        OpenStdin: boolean;
+        StdinOnce: boolean;
+        Env?: string[];
+        Cmd?: string[];
+        Healthcheck?: HealthConfig;
+        ArgsEscaped: boolean | null;
+        Image: string;
+        Volumes?: Record<string, object>;
+        WorkingDir: string;
+        Entrypoint?: string[];
+        NetworkDisabled?: boolean;
+        MacAddress?: string;
+        OnBuild?: string[];
+        Labels?: Record<string, string>;
+        StopSignal?: string;
+        StopTimeout?: number;
+        Shell?: string[];
+    }
+    /**
+     * Host configuration
+     */
+    export interface HostConfig {
+        Binds?: string[];
+        ContainerIDFile?: string;
+        LogConfig?: LogConfig;
+        NetworkMode?: string;
+        PortBindings?: Record<string, PortBinding[]>;
+        RestartPolicy?: RestartPolicy;
+        AutoRemove?: boolean;
+        VolumeDriver?: string;
+        VolumesFrom?: string[];
+        CapAdd?: string[];
+        CapDrop?: string[];
+        CgroupnsMode?: string;
+        Dns?: string[];
+        DnsOptions?: string[];
+        DnsSearch?: string[];
+        ExtraHosts?: string[];
+        GroupAdd?: string[];
+        IpcMode?: string;
+        Cgroup?: string;
+        Links?: string[];
+        OomScoreAdj?: number;
+        PidMode?: string;
+        Privileged?: boolean;
+        PublishAllPorts?: boolean;
+        ReadonlyRootfs?: boolean;
+        SecurityOpt?: string[];
+        StorageOpt?: Record<string, string>;
+        Tmpfs?: Record<string, string>;
+        UTSMode?: string;
+        UsernsMode?: string;
+        ShmSize?: number;
+        Sysctls?: Record<string, string>;
+        Runtime?: string;
+        ConsoleSize?: number[];
+        Isolation?: string;
+        Resources?: Resources;
+        MaskedPaths?: string[];
+        ReadonlyPaths?: string[];
+    }
+    /**
+     * Container stats
+     */
+    export interface ContainerStatsResponse {
+        id?: string;
+        name?: string;
+        os_type?: string;
+        read: string;
+        cpu_stats: ContainerCPUStats;
+        memory_stats: ContainerMemoryStats;
+        networks?: Record<string, ContainerNetworkStats>;
+        pids_stats?: ContainerPidsStats;
+        blkio_stats: ContainerBlkioStats;
+        num_procs?: number;
+        storage_stats?: ContainerStorageStats;
+    }
+    /**
+     * CPU stats
+     */
+    export interface ContainerCPUStats {
+        cpu_usage: ContainerCPUUsage;
+        system_cpu_usage: number;
+        online_cpus?: number;
+        throttling_data?: ContainerThrottlingData;
+    }
+    /**
+     * CPU usage
+     */
+    export interface ContainerCPUUsage {
+        total_usage: number;
+        percpu_usage?: number[];
+        usage_in_kernelmode: number;
+        usage_in_usermode: number;
+    }
+    /**
+     * Throttling data
+     */
+    export interface ContainerThrottlingData {
+        periods: number;
+        throttled_periods: number;
+        throttled_time: number;
+    }
+    /**
+     * Memory stats
+     */
+    export interface ContainerMemoryStats {
+        usage: number;
+        max_usage?: number;
+        stats?: Record<string, number>;
+        failcnt?: number;
+        limit: number;
+        commitbytes?: number;
+        commitpeakbytes?: number;
+        privateworkingset?: number;
+    }
+    /**
+     * PIDs stats
+     */
+    export interface ContainerPidsStats {
+        current?: number;
+        limit?: number;
+    }
+    /**
+     * Block I/O stats
+     */
+    export interface ContainerBlkioStats {
+        io_service_bytes_recursive?: ContainerBlkioStatEntry[];
+        io_serviced_recursive?: ContainerBlkioStatEntry[];
+        io_queue_recursive?: ContainerBlkioStatEntry[];
+        io_service_time_recursive?: ContainerBlkioStatEntry[];
+        io_wait_time_recursive?: ContainerBlkioStatEntry[];
+        io_merged_recursive?: ContainerBlkioStatEntry[];
+        io_time_recursive?: ContainerBlkioStatEntry[];
+        sectors_recursive?: ContainerBlkioStatEntry[];
+    }
+    /**
+     * Block I/O stat entry
+     */
+    export interface ContainerBlkioStatEntry {
+        major: number;
+        minor: number;
+        op: string;
+        value: number;
+    }
+    /**
+     * Network stats
+     */
+    export interface ContainerNetworkStats {
+        rx_bytes: number;
+        rx_packets: number;
+        rx_errors: number;
+        rx_dropped: number;
+        tx_bytes: number;
+        tx_packets: number;
+        tx_errors: number;
+        tx_dropped: number;
+    }
+    /**
+     * Storage stats
+     */
+    export interface ContainerStorageStats {
+        read_count_normalized?: number;
+        read_size_bytes?: number;
+        write_count_normalized?: number;
+        write_size_bytes?: number;
+    }
+    /**
+     * Top processes
+     */
+    export interface ContainerTopResponse {
+        Titles: string[];
+        Processes: string[][];
+    }
+    /**
+     * Wait response
+     */
+    export interface ContainerWaitResponse {
+        StatusCode: number;
+        Error?: ContainerWaitExitError;
+    }
+    /**
+     * Wait exit error
+     */
+    export interface ContainerWaitExitError {
+        Message: string;
+    }
+    /**
+     * Create container response
+     */
+    export interface ContainerCreateResponse {
+        Id: string;
+        Warnings?: string[];
+    }
+    /**
+     * Update container response
+     */
+    export interface ContainerUpdateResponse {
+        Warnings?: string[];
+    }
+    /**
+     * Container prune response
+     */
+    export interface ContainerPruneResponse {
+        ContainersDeleted?: string[];
+        SpaceReclaimed: number;
+    }
+    /**
+     * Health status
+     */
+    export interface Health {
+        Status: string;
+        FailingStreak?: number;
+        Log?: HealthcheckResult[];
+    }
+    /**
+     * Health check configuration
+     */
+    export interface HealthConfig {
+        Test?: string[];
+        Interval?: number;
+        Timeout?: number;
+        Retries?: number;
+        StartPeriod?: number;
+        StartInterval?: number;
+    }
+    /**
+     * Health check result
+     */
+    export interface HealthcheckResult {
+        Start: string;
+        End: string;
+        ExitCode: number;
+        Output: string;
+    }
+    /**
+     * Port
+     */
+    export interface Port {
+        IP: string;
+        PrivatePort: number;
+        PublicPort?: number;
+        Type: string;
+    }
+    /**
+     * Port binding
+     */
+    export interface PortBinding {
+        HostIp: string;
+        HostPort: string;
+    }
+    /**
+     * Restart policy
+     */
+    export interface RestartPolicy {
+        Name: string;
+        MaximumRetryCount?: number;
+    }
+    /**
+     * Resources
+     */
+    export interface Resources {
+        CpuShares?: number;
+        Memory?: number;
+        NanoCpus?: number;
+        CpuPeriod?: number;
+        CpuQuota?: number;
+        CpuRealtimePeriod?: number;
+        CpuRealtimeRuntime?: number;
+        CpusetCpus?: string;
+        CpusetMems?: string;
+        BlkioWeight?: number;
+        BlkioWeightDevice?: {
+            Path: string;
+            Weight: number;
+        }[];
+        BlkioDeviceReadBps?: {
+            Path: string;
+            Rate: number;
+        }[];
+        BlkioDeviceWriteBps?: {
+            Path: string;
+            Rate: number;
+        }[];
+        BlkioDeviceReadIOps?: {
+            Path: string;
+            Rate: number;
+        }[];
+        BlkioDeviceWriteIOps?: {
+            Path: string;
+            Rate: number;
+        }[];
+        MemoryReservation?: number;
+        MemorySwap?: number;
+        MemorySwappiness?: number;
+        OomKillDisable?: boolean;
+        PidsLimit?: number;
+        Ulimits?: {
+            Name: string;
+            Soft: number;
+            Hard: number;
+        }[];
+    }
+    /**
+     * Graph driver
+     */
+    export interface GraphDriver {
+        Name: string;
+        Data: Record<string, string>;
+    }
+    /**
+     * Mount
+     */
+    export interface Mount {
+        Type: string;
+        Name?: string;
+        Source?: string;
+        Destination: string;
+        Driver?: string;
+        Mode?: string;
+        RW?: boolean;
+        Propagation?: string;
+    }
+    /**
+     * Log config
+     */
+    export interface LogConfig {
+        Type: string;
+        Config?: Record<string, string>;
+    }
+    /**
+     * Network settings
+     */
+    export interface NetworkSettings {
+        SandboxID: string;
+        SandboxKey: string;
+        Ports?: Record<string, PortBinding[]>;
+        Networks?: Record<string, NetworkSummary>;
+    }
+    /**
+     * Network summary
+     */
+    export interface NetworkSummary {
+        EndpointID?: string;
+        Gateway?: string;
+        IPAddress?: string;
+        IPPrefixLen?: number;
+        IPv6Gateway?: string;
+        GlobalIPv6Address?: string;
+        GlobalIPv6PrefixLen?: number;
+        MacAddress?: string;
+        NetworkID?: string;
+    }
+    /**
+     * Filesystem change
+     */
+    export interface FilesystemChange {
+        Path: string;
+        Kind: number;
+    }
+    /**
+     * Exec create options
+     */
+    export interface ExecCreateOptions {
+        AttachStdin?: boolean;
+        AttachStdout?: boolean;
+        AttachStderr?: boolean;
+        DetachKeys?: string;
+        Tty?: boolean;
+        Env?: string[];
+        Cmd?: string[];
+        Privileged?: boolean;
+        User?: string;
+        WorkingDir?: string;
+    }
+    /**
+     * Exec create response
+     */
+    export interface ExecCreateResponse {
+        Id: string;
+    }
+    /**
+     * Exec start options
+     */
+    export interface ExecStartOptions {
+        Detach?: boolean;
+        Tty?: boolean;
+        ConsoleSize?: number[];
+    }
+    /**
+     * Exec inspect response
+     */
+    export interface ExecInspectResponse {
+        CanRemove: boolean;
+        DetachKeys: string;
+        ID: string;
+        Running: boolean;
+        ExitCode: number;
+        ProcessConfig: {
+            arguments: string[];
+            entrypoint: string;
+            privileged: boolean;
+            tty: boolean;
+            user: string;
+        };
+        OpenStdin: boolean;
+        OpenStderr: boolean;
+        OpenStdout: boolean;
+        ContainerID: string;
+        Pid: number;
+    }
+    /**
+     * Archive info
+     */
+    export interface ArchiveInfo {
+        name: string;
+        size: number;
+        mode: number;
+        mtime: string;
+        linkTarget?: string;
+    }
+    /**
+     * Network config
+     */
+    export interface NetworkingConfig {
+        EndpointsConfig?: Record<string, EndpointSettings>;
+    }
+    /**
+     * Endpoint settings
+     */
+    export interface EndpointSettings {
+        IPAMConfig?: {
+            IPv4Address?: string;
+            IPv6Address?: string;
+            LinkLocalIPs?: string[];
+        };
+        Links?: string[];
+        Aliases?: string[];
+        NetworkID?: string;
+        EndpointID?: string;
+        Gateway?: string;
+        IPAddress?: string;
+        IPPrefixLen?: number;
+        IPv6Gateway?: string;
+        GlobalIPv6Address?: string;
+        GlobalIPv6PrefixLen?: number;
+        MacAddress?: string;
+        DriverOpts?: Record<string, string>;
+    }
+    /**
+     * List containers options
+     */
+    export interface ListContainersOptions {
+        all?: boolean;
+        limit?: number;
+        size?: boolean;
+        filters?: {
+            ancestor?: string[];
+            before?: string[];
+            expose?: string[];
+            exited?: number[];
+            health?: string[];
+            id?: string[];
+            isolation?: string[];
+            label?: string[];
+            name?: string[];
+            network?: string[];
+            publish?: string[];
+            since?: string[];
+            status?: string[];
+            volume?: string[];
+        };
+    }
+    /**
+     * Create container options
+     */
+    export interface CreateContainerOptions {
+        name?: string;
+        platform?: string;
+        HostConfig?: HostConfig;
+        NetworkingConfig?: NetworkingConfig;
+    }
+    /**
+     * Update container options
+     */
+    export interface UpdateContainerOptions {
+        BlkioWeight?: number;
+        CpuShares?: number;
+        CpuPeriod?: number;
+        CpuQuota?: number;
+        CpuRealtimePeriod?: number;
+        CpuRealtimeRuntime?: number;
+        CpusetCpus?: string;
+        CpusetMems?: string;
+        Memory?: number;
+        MemorySwap?: number;
+        MemoryReservation?: number;
+        RestartPolicy?: RestartPolicy;
+    }
+    /**
+     * Attach options
+     */
+    export interface AttachOptions {
+        detachKeys?: string;
+        log?: boolean;
+        stream?: boolean;
+        stdin?: boolean;
+        stdout?: boolean;
+        stderr?: boolean;
+    }
+    /**
+     * Logs options
+     */
+    export interface LogsOptions {
+        follow?: boolean;
+        stdout?: boolean;
+        stderr?: boolean;
+        since?: number;
+        until?: number;
+        timestamps?: boolean;
+        tail?: string;
+    }
+    /**
+     * Wait condition
+     */
+    export type WaitCondition = "not-running" | "next-exit" | "removed";
+    /**
+     * Prune containers options
+     */
+    export interface PruneContainersOptions {
+        filters?: {
+            label?: string[];
+            until?: string;
+        };
+    }
+    /**
+     * Stats options
+     */
+    export interface StatsOptions {
+        stream?: boolean;
+        "one-shot"?: boolean;
+    }
+    /**
+     * Change type
+     */
+    export enum ChangeType {
+        Modified = 0,
+        Added = 1,
+        Deleted = 2
+    }
+}
+declare module "modules/container/index" {
+    import type { BodyInit } from "bun";
+    import { BaseModule } from "modules/base/index";
+    import type { DockerWebSocket } from "modules/_socket/index";
+    import type { ArchiveInfo, AttachOptions, ContainerConfig, ContainerCreateResponse, ContainerInspectResponse, ContainerPruneResponse, ContainerStatsResponse, ContainerSummary, ContainerTopResponse, ContainerUpdateResponse, ContainerWaitResponse, CreateContainerOptions, ExecCreateOptions, ExecCreateResponse, ExecInspectResponse, ExecStartOptions, FilesystemChange, ListContainersOptions, LogsOptions, PruneContainersOptions, StatsOptions, UpdateContainerOptions, WaitCondition } from "modules/container/types";
+    /**
+     * Container Module - handles all Docker container operations
+     */
+    export class ContainerModule extends BaseModule {
+        /**
+         * List containers
+         * @param options - List options
+         * @returns Array of container summaries
+         */
+        list(options?: ListContainersOptions): Promise<ContainerSummary[]>;
+        /**
+         * Create a container
+         * @param config - Container configuration
+         * @param options - Create options
+         * @returns Container create response with ID
+         */
+        create(config: ContainerConfig, options?: CreateContainerOptions): Promise<ContainerCreateResponse>;
+        /**
+         * Inspect a container
+         * @param id - Container ID or name
+         * @param size - Return container size information
+         * @returns Detailed container information
+         */
+        inspect(id: string, size?: boolean): Promise<ContainerInspectResponse>;
+        /**
+         * Start a container
+         * @param id - Container ID or name
+         * @param detachKeys - Override the key sequence for detaching
+         */
+        start(id: string, detachKeys?: string): Promise<void>;
+        /**
+         * Stop a container
+         * @param id - Container ID or name
+         * @param t - Number of seconds to wait before killing the container
+         */
+        stop(id: string, t?: number): Promise<void>;
+        /**
+         * Restart a container
+         * @param id - Container ID or name
+         * @param t - Number of seconds to wait before killing the container
+         */
+        restart(id: string, t?: number): Promise<void>;
+        /**
+         * Kill a container
+         * @param id - Container ID or name
+         * @param signal - Signal to send to the container
+         */
+        kill(id: string, signal?: string): Promise<void>;
+        /**
+         * Remove a container
+         * @param id - Container ID or name
+         * @param v - Remove anonymous volumes associated with the container
+         * @param force - Force removal of running containers
+         * @param link - Remove the specified link associated with the container
+         */
+        remove(id: string, v?: boolean, force?: boolean, link?: boolean): Promise<void>;
+        /**
+         * Rename a container
+         * @param id - Container ID or name
+         * @param name - New name for the container
+         */
+        rename(id: string, name: string): Promise<void>;
+        /**
+         * Pause a container
+         * @param id - Container ID or
+       name
+         */
+        pause(id: string): Promise<void>;
+        /**
+         * Unpause a container
+         * @param id - Container ID or name
+         */
+        unpause(id: string): Promise<void>;
+        /**
+         * Wait for a container
+         * @param id - Container ID or name
+         * @param condition - Wait until condition is met
+         * @returns Container wait response with exit status
+         */
+        wait(id: string, condition?: WaitCondition): Promise<ContainerWaitResponse>;
+        /**
+         * List processes running inside a container
+         * @param id - Container ID or name
+         * @param ps_args - Arguments for ps command
+         * @returns Top processes response
+         */
+        top(id: string, ps_args?: string): Promise<ContainerTopResponse>;
+        /**
+         * Get container logs
+         * @param id - Container ID or name
+         * @param options - Log options
+         * @returns Log stream
+         */
+        logs(id: string, options?: LogsOptions): Promise<Response>;
+        /**
+         * Get container resource usage statistics
+         * @param id - Container ID or name
+         * @param options - Stats options
+         * @returns Container stats response
+         */
+        stats(id: string, options?: StatsOptions): Promise<ContainerStatsResponse | Response>;
+        /**
+         * Get changes on container filesystem
+         * @param id - Container ID or name
+         * @returns Array of filesystem changes
+         */
+        changes(id: string): Promise<FilesystemChange[]>;
+        /**
+         * Export a container
+         * @param id - Container ID or name
+         * @returns Exported container archive
+         */
+        export(id: string): Promise<Response>;
+        /**
+         * Update container configuration
+         * @param id - Container ID or name
+         * @param options - Update options
+         * @returns Update response with warnings
+         */
+        update(id: string, options: UpdateContainerOptions): Promise<ContainerUpdateResponse>;
+        /**
+         * Resize container TTY
+         * @param id - Container ID or name
+         * @param h - Height of the TTY session
+         * @param w - Width of the TTY session
+         */
+        resize(id: string, h: number, w: number): Promise<void>;
+        /**
+         * Attach to a container
+         * @param id - Container ID or name
+         * @param options - Attach options
+         * @returns Attach connection
+         */
+        attach(id: string, options?: AttachOptions): Promise<Response>;
+        /**
+         * Attach to a container via WebSocket
+         * @param id - Container ID or name
+         * @param options - Attach options
+         * @returns WebSocket-like connection
+         * @note Uses the attach endpoint with stream wrapping for compatibility with Unix sockets
+         */
+        attachWebSocket(id: string, options?: AttachOptions): Promise<DockerWebSocket>;
+        /**
+         * Get an archive of a filesystem resource in a container
+         * @param id - Container ID or name
+         * @param path - Resource path in the container
+         * @returns Archive stream
+         */
+        getArchive(id: string, path: string): Promise<Response>;
+        /**
+         * Check if a file exists in a container
+         * @param id - Container ID or name
+         * @param path - Resource path in the container
+         * @returns Archive info or null
+         */
+        archiveInfo(id: string, path: string): Promise<ArchiveInfo | null>;
+        /**
+         * Extract an archive of files or folders to a directory in the container
+         * @param id - Container ID or name
+         * @param path - Path to extract to
+         * @param archive - Archive to extract
+         * @param noOverwriteDirNonDir - If true, will not overwrite a dir with a non-dir
+         * @param copyUIDGID - If set to true, copy ownership from archive to target
+         */
+        putArchive(id: string, path: string, archive: BodyInit, noOverwriteDirNonDir?: boolean, copyUIDGID?: boolean): Promise<void>;
+        /**
+         * Create an exec instance
+         * @param id - Container ID or name
+         * @param options - Exec create options
+         * @returns Exec create response with exec ID
+         */
+        execCreate(id: string, options: ExecCreateOptions): Promise<ExecCreateResponse>;
+        /**
+         * Start an exec instance
+         * @param id - Exec ID
+         * @param options - Exec start options
+         * @returns Exec stream
+         */
+        execStart(id: string, options?: ExecStartOptions): Promise<Response>;
+        /**
+         * Inspect an exec instance
+         * @param id - Exec ID
+         * @returns Exec inspect response
+         */
+        execInspect(id: string): Promise<ExecInspectResponse>;
+        /**
+         * Resize an exec TTY
+         * @param id - Exec ID
+         * @param h - Height of the TTY session
+         * @param w - Width of the TTY session
+         */
+        execResize(id: string, h: number, w: number): Promise<void>;
+        /**
+         * Delete stopped containers
+         * @param options - Prune options
+         * @returns Prune response with deleted containers and reclaimed space
+         */
+        prune(options?: PruneContainersOptions): Promise<ContainerPruneResponse>;
+    }
+}
+declare module "modules/distribution/types" {
+    export type ImageInformationResponse = {
+        Descriptor: {
+            mediaType: string;
+            digest: string;
+            size: number;
+            urls: string[] | null;
+            annotations: Record<string, string> | null;
+            data: string | null;
+            platform: {
+                architecture: string;
+                os: string;
+                "os.version"?: string;
+                "os.features"?: string[];
+            } | null;
+            artifactType: string | null;
+        };
+        Platforms: Array<{
+            architecture: string;
+            os: string;
+            "os.version"?: string;
+            "os.features"?: string[];
+            variant?: string;
+        }>;
+    };
+}
+declare module "modules/distribution/index" {
+    import { BaseModule } from "modules/base/index";
+    import type { ImageInformationResponse } from "modules/distribution/types";
+    export class DistributionModule extends BaseModule {
+        /**
+         * Return image digest and platform information by contacting the registry.
+         * @param image Image name or id
+         */
+        getImageInfo(image: string): Promise<ImageInformationResponse>;
+    }
+}
+declare module "modules/exec/types" {
+    /**
+     * Exec instance create options
+     */
+    export interface ExecCreateOptions {
+        AttachStdin?: boolean;
+        AttachStdout?: boolean;
+        AttachStderr?: boolean;
+        ConsoleSize?: [number, number] | null;
+        DetachKeys?: string;
+        Tty?: boolean;
+        Env?: string[];
+        Cmd?: string[];
+        Privileged?: boolean;
+        User?: string;
+        WorkingDir?: string;
+    }
+    /**
+     * Exec create response
+     */
+    export interface ExecCreateResponse {
+        Id: string;
+    }
+    /**
+     * Exec start options
+     */
+    export interface ExecStartOptions {
+        Detach?: boolean;
+        Tty?: boolean;
+        ConsoleSize?: [number, number] | null;
+    }
+    /**
+     * Exec inspect response
+     */
+    export interface ExecInspectResponse {
+        CanRemove: boolean;
+        DetachKeys: string;
+        ID: string;
+        Running: boolean;
+        ExitCode: number;
+        ProcessConfig: ProcessConfig;
+        OpenStdin: boolean;
+        OpenStderr: boolean;
+        OpenStdout: boolean;
+        ContainerID: string;
+        Pid: number;
+    }
+    /**
+     * Process configuration
+     */
+    export interface ProcessConfig {
+        arguments: string[];
+        entrypoint: string;
+        privileged: boolean;
+        tty: boolean;
+        user: string;
+    }
+}
+declare module "modules/exec/index" {
+    import { BaseModule } from "modules/base/index";
+    import type { ExecCreateOptions, ExecCreateResponse, ExecInspectResponse, ExecStartOptions } from "modules/exec/types";
+    /**
+     * Exec Module - handles all Docker exec operations
+     */
+    export class ExecModule extends BaseModule {
+        /**
+         * Create an exec instance
+         * @param containerId - Container ID or name
+         * @param options - Exec configuration
+         * @returns Exec create response with ID
+         */
+        create(containerId: string, options: ExecCreateOptions): Promise<ExecCreateResponse>;
+        /**
+         * Start an exec instance
+         * @param execId - Exec instance ID
+         * @param options - Start configuration
+         * @returns Response object (for streaming)
+         */
+        start(execId: string, options?: ExecStartOptions): Promise<Response>;
+        /**
+         * Inspect an exec instance
+         * @param execId - Exec instance ID
+         * @returns Detailed exec instance information
+         */
+        inspect(execId: string): Promise<ExecInspectResponse>;
+        /**
+         * Resize an exec instance TTY session
+         * @param execId - Exec instance ID
+         * @param height - Height of TTY session in characters
+         * @param width - Width of TTY session in characters
+         */
+        resize(execId: string, height: number, width: number): Promise<void>;
+    }
+}
+declare module "modules/images/types" {
+    import type { BodyInit } from "bun";
+    /**
+     * Image summary information returned by list
+     */
+    export interface ImageSummary {
+        Id: string;
+        ParentId: string;
+        RepoTags: string[];
+        RepoDigests: string[];
+        Created: number;
+        Size: number;
+        SharedSize: number;
+        Labels?: Record<string, string>;
+        Containers: number;
+        Manifests?: ImageManifestSummary[];
+        Descriptor?: OCIDescriptor;
+    }
+    /**
+     * Detailed image information returned by inspect
+     */
+    export interface ImageInspect {
+        Id: string;
+        Descriptor?: OCIDescriptor;
+        Identity?: Identity;
+        Manifests?: ImageManifestSummary[];
+        RepoTags?: string[];
+        RepoDigests?: string[];
+        Comment?: string;
+        Created?: string;
+        Author?: string;
+        Config?: ImageConfig;
+        Architecture?: string;
+        Variant?: string;
+        Os?: string;
+        OsVersion?: string;
+        Size?: number;
+        GraphDriver?: GraphDriver;
+        RootFS?: RootFS;
+        Metadata?: ImageMetadata;
+    }
+    /**
+     * Image configuration
+     */
+    export interface ImageConfig {
+        User?: string;
+        ExposedPorts?: Record<string, object>;
+        Env?: string[];
+        Cmd?: string[];
+        Healthcheck?: HealthConfig;
+        ArgsEscaped?: boolean;
+        Volumes?: Record<string, object>;
+        WorkingDir?: string;
+        Entrypoint?: string[];
+        OnBuild?: string[];
+        Labels?: Record<string, string>;
+        StopSignal?: string;
+        Shell?: string[];
+    }
+    /**
+     * Root filesystem information
+     */
+    export interface RootFS {
+        Type: string;
+        Layers: string[];
+    }
+    /**
+     * Image metadata
+     */
+    export interface ImageMetadata {
+        LastTagTime?: string;
+    }
+    /**
+     * Graph driver information
+     */
+    export interface GraphDriver {
+        Name: string;
+        Data: Record<string, string>;
+    }
+    /**
+     * Image history item
+     */
+    export interface ImageHistoryResponseItem {
+        Id: string;
+        Created: number;
+        CreatedBy: string;
+        Tags: string[];
+        Size: number;
+        Comment: string;
+    }
+    /**
+     * Image delete response item
+     */
+    export interface ImageDeleteResponseItem {
+        Untagged?: string;
+        Deleted?: string;
+    }
+    /**
+     * Images disk usage
+     */
+    export interface ImagesDiskUsage {
+        ActiveCount: number;
+        TotalCount: number;
+        Reclaimable: number;
+        TotalSize: number;
+        Items?: ImageSummary[];
+    }
+    /**
+     * Image search result
+     */
+    export interface ImageSearchResponseItem {
+        description: string;
+        is_official: boolean;
+        is_automated: boolean;
+        name: string;
+        star_count: number;
+    }
+    /**
+     * Image prune response
+     */
+    export interface ImagePruneResponse {
+        ImagesDeleted?: ImageDeleteResponseItem[];
+        SpaceReclaimed: number;
+    }
+    /**
+     * OCI descriptor
+     */
+    export interface OCIDescriptor {
+        mediaType: string;
+        digest: string;
+        size: number;
+        urls?: string[];
+        annotations?: Record<string, string>;
+        data?: string;
+        platform?: OCIPlatform;
+        artifactType?: string;
+    }
+    /**
+     * OCI platform
+     */
+    export interface OCIPlatform {
+        architecture: string;
+        os: string;
+        "os.version"?: string;
+        "os.features"?: string[];
+        variant?: string;
+    }
+    /**
+     * Image manifest summary
+     */
+    export interface ImageManifestSummary {
+        ID: string;
+        Descriptor: OCIDescriptor;
+        Available: boolean;
+        Size: {
+            Total: number;
+            Content: number;
+        };
+        Kind: "manifest" | "index" | "unknown";
+        ImageData?: {
+            Platform: OCIPlatform;
+            Identity?: Identity;
+            Containers?: string[];
+            Size?: {
+                Unpacked: number;
+            };
+        };
+        AttestationData?: {
+            For: string;
+        };
+    }
+    /**
+     * Identity information
+     */
+    export interface Identity {
+        Signature?: SignatureIdentity[];
+        Pull?: PullIdentity[];
+        Build?: BuildIdentity[];
+    }
+    /**
+     * Build identity
+     */
+    export interface BuildIdentity {
+        Ref: string;
+        CreatedAt: string;
+    }
+    /**
+     * Pull identity
+     */
+    export interface PullIdentity {
+        Repository: string;
+    }
+    /**
+     * Signature identity
+     */
+    export interface SignatureIdentity {
+        Name: string;
+        Timestamps: SignatureTimestamp[];
+        KnownSigner?: KnownSignerIdentity;
+        DockerReference?: string;
+        Signer?: SignerIdentity;
+        SignatureType?: SignatureType;
+        Error?: string;
+        Warnings?: string[];
+    }
+    /**
+     * Signature timestamp
+     */
+    export interface SignatureTimestamp {
+        Type: SignatureTimestampType;
+        URI?: string;
+        Timestamp: string;
+    }
+    /**
+     * Signature timestamp type
+     */
+    export type SignatureTimestampType = "sig" | "exp" | "att";
+    /**
+     * Signature type
+     */
+    export type SignatureType = "cosign" | "notation" | "sbom";
+    /**
+     * Known signer identity
+     */
+    export type KnownSignerIdentity = "docker-official" | "docker-notary-service";
+    /**
+     * Signer identity
+     */
+    export interface SignerIdentity {
+        CertificateIssuer?: string;
+        SubjectAlternativeName?: string;
+        Issuer?: string;
+        BuildSignerURI?: string;
+        BuildSignerDigest?: string;
+        RunnerEnvironment?: string;
+        SourceRepositoryURI?: string;
+        SourceRepositoryDigest?: string;
+        SourceRepositoryRef?: string;
+        SourceRepositoryIdentifier?: string;
+        SourceRepositoryOwnerURI?: string;
+        SourceRepositoryOwnerIdentifier?: string;
+        BuildConfigURI?: string;
+        BuildConfigDigest?: string;
+        BuildTrigger?: string;
+        RunInvocationURI?: string;
+        SourceRepositoryVisibilityAtSigning?: string;
+    }
+    /**
+     * Image ID
+     */
+    export interface ImageID {
+        Id: string;
+    }
+    /**
+     * Create image information
+     */
+    export interface CreateImageInfo {
+        id?: string;
+        errorDetail?: ErrorDetail;
+        status?: string;
+        progressDetail?: ProgressDetail;
+    }
+    /**
+     * Push image information
+     */
+    export interface PushImageInfo {
+        errorDetail?: ErrorDetail;
+        status?: string;
+        progressDetail?: ProgressDetail;
+    }
+    /**
+     * Error detail
+     */
+    export interface ErrorDetail {
+        code?: number;
+        message: string;
+    }
+    /**
+     * Progress detail
+     */
+    export interface ProgressDetail {
+        current?: number;
+        total?: number;
+    }
+    /**
+     * Health configuration
+     */
+    export interface HealthConfig {
+        Test?: string[];
+        Interval?: number;
+        Timeout?: number;
+        Retries?: number;
+        StartPeriod?: number;
+        StartInterval?: number;
+    }
+    /**
+     * Build cache disk usage
+     */
+    export interface BuildCacheDiskUsage {
+        ActiveCount: number;
+        TotalCount: number;
+        Reclaimable: number;
+        TotalSize: number;
+        Items?: BuildCache[];
+    }
+    /**
+     * Build cache
+     */
+    export interface BuildCache {
+        ID: string;
+        Parents?: string[];
+        Type: string;
+        Description?: string;
+        InUse?: boolean;
+        Shared?: boolean;
+        Size?: number;
+        CreatedAt: string;
+        LastUsedAt?: string;
+        UsageCount?: number;
+    }
+    /**
+     * List images options
+     */
+    export interface ListImagesOptions {
+        all?: boolean;
+        filters?: {
+            before?: string[];
+            dangling?: string[];
+            label?: string[];
+            reference?: string[];
+            since?: string[];
+            until?: string[];
+        };
+        sharedSize?: boolean;
+        digests?: boolean;
+        manifests?: boolean;
+        identity?: boolean;
+    }
+    /**
+     * Pull image options
+     */
+    export interface PullImageOptions {
+        fromImage: string;
+        tag?: string;
+        platform?: string;
+        fromSrc?: string;
+        repo?: string;
+        message?: string;
+        inputImage?: BodyInit;
+        changes?: string[];
+        authHeader?: string;
+    }
+    /**
+     * Push image options
+     */
+    export interface PushImageOptions {
+        tag?: string;
+        platform?: string;
+        authHeader: string;
+    }
+    /**
+     * Tag image options
+     */
+    export interface TagImageOptions {
+        repo: string;
+        tag?: string;
+    }
+    /**
+     * Remove image options
+     */
+    export interface RemoveImageOptions {
+        force?: boolean;
+        noprune?: boolean;
+        platforms?: string[];
+    }
+    /**
+     * Search images options
+     */
+    export interface SearchImagesOptions {
+        term: string;
+        limit?: number;
+        filters?: {
+            "is-official"?: string[];
+            stars?: string[];
+        };
+    }
+    /**
+     * Prune images options
+     */
+    export interface PruneImagesOptions {
+        filters?: {
+            dangling?: string[];
+            until?: string[];
+            label?: string[];
+        };
+    }
+    /**
+     * Inspect image options
+     */
+    export interface InspectImageOptions {
+        manifests?: boolean;
+        platform?: string;
+    }
+    /**
+     * History image options
+     */
+    export interface HistoryImageOptions {
+        platform?: string;
+    }
+    /**
+     * Export image options
+     */
+    export interface ExportImageOptions {
+        name: string;
+        platform?: string[];
+    }
+    /**
+     * Export all images options
+     */
+    export interface ExportAllImagesOptions {
+        names?: string[];
+        platform?: string[];
+    }
+    /**
+     * Load image options
+     */
+    export interface LoadImageOptions {
+        imagesTarball: BodyInit;
+        quiet?: boolean;
+        platform?: string[];
+    }
+    /**
+     * Build image options
+     */
+    export interface BuildImageOptions {
+        inputStream?: BodyInit;
+        dockerfile?: string;
+        t?: string;
+        extrahosts?: string;
+        remote?: string;
+        q?: boolean;
+        nocache?: boolean;
+        cachefrom?: string;
+        pull?: string;
+        rm?: boolean;
+        forcerm?: boolean;
+        memory?: number;
+        memswap?: number;
+        cpushares?: number;
+        cpusetcpus?: string;
+        cpuperiod?: number;
+        cpuquota?: number;
+        buildargs?: string;
+        shmsize?: number;
+        squash?: boolean;
+        labels?: string;
+        networkmode?: string;
+        authConfig?: string;
+        platform?: string;
+        target?: string;
+        outputs?: string;
+        version?: "1" | "2";
+    }
+    /**
+     * Prune build cache options
+     */
+    export interface PruneBuildCacheOptions {
+        all?: boolean;
+        "keep-storage"?: number;
+        filters?: {
+            until?: string;
+            id?: string[];
+        };
+    }
+    /**
+     *
+     */
+    export interface CommitParams {
+        container: string;
+        repo: string;
+        tag: string;
+        comment: string;
+        author: string;
+        pause: boolean;
+        changes: string;
+    }
+    export interface CommitBody {
+        /** The hostname to use for the container, as a valid RFC 1123 hostname. */
+        Hostname: string;
+        /** The domain name to use for the container. */
+        Domainname: string;
+        /**
+         * Commands run as this user inside the container.
+         * If omitted, commands run as the user
+         * specified in the image the container was started from.
+         *
+         * Can be either user-name or UID, and optional group-name or GID,
+         * separated by a colon (`<user-name|UID>[<:group-name|GID>]`).
+         */
+        User: string;
+        /**
+         * Whether to attach to stdin.
+         * Default: false
+         */
+        AttachStdin: boolean;
+        /**
+         * Whether to attach to stdout.
+         * Default: true
+         */
+        AttachStdout: boolean;
+        /**
+         * Whether to attach to stderr.
+         * Default: true
+         */
+        AttachStderr: boolean;
+        /**
+         * An object mapping ports to an empty object in the form: {"<port>/<tcp|udp|sctp>": {}}
+         */
+        ExposedPorts: null | Record<string, unknown>;
+        /**
+         * Attach standard streams to a TTY, including stdin if it is not closed.
+         * Default: false
+         */
+        Tty: boolean;
+        /** Default: false */
+        OpenStdin: boolean;
+        /**
+         * Close stdin after one attached client disconnects
+         * Default: false
+         */
+        StdinOnce: boolean;
+        /**
+         * A list of environment variables to set inside the container
+         * in the form ["VAR=value", ...].
+         * A variable without = is removed from the environment,
+         * rather than to have an empty value.
+         */
+        Env: string[];
+        /** Command to run specified as a string or an array of strings. */
+        Cmd: string | string[];
+        /**
+         * A test to perform to check that the container is healthy.
+         * Healthcheck commands should be side-effect free.
+         */
+        HealthCheck: {
+            /**
+             * The test to perform. Possible values are:
+             * - [] inherit healthcheck from image or parent image
+             * - ["NONE"] disable healthcheck
+             * - ["CMD", args...] exec arguments directly
+             * - ["CMD-SHELL", command] run command with system's default shell
+             * A non-zero exit code indicates a failed healthcheck:
+             * - 0 healthy
+             * - 1 unhealthy
+             * - 2 reserved (treated as unhealthy)
+             * - other values: error running probe
+             */
+            Test: string[];
+            /**
+             * The time to wait between checks in nanoseconds.
+             * It should be 0 or at least 1000000 (1 ms). 0 means inherit.
+             */
+            Interval: number;
+            /**
+             * The time to wait before considering the check to have hung.
+             * It should be 0 or at least 1000000 (1 ms). 0 means inherit.
+             */
+            Timeout: number;
+            /**
+             * The number of consecutive failures needed to consider a container as unhealthy.
+             * 0 means inherit.
+             */
+            Retries: number;
+            /** Start period for the container to initialize before starting health-retries
+             * countdown in nanoseconds.
+             * It should be 0 or at least 1000000 (1 ms).
+             * 0 means inherit.
+             * */
+            StartPeriod: number;
+            /**
+             * The time to wait between checks in nanoseconds during the start period.
+             * It should be 0 or at least 1000000 (1 ms).
+             * 0 means inherit.
+             */
+            StartInterval: number;
+        };
+        /**
+         * Command is already escaped (Windows only)
+         * Default: false
+         * */
+        ArgsEscaped: boolean | null;
+        /**
+         * The name (or reference) of the image to use when creating the container,
+         * or which was used when the container was created.
+         */
+        Image: string;
+        /**
+         * An object mapping mount point paths inside the container to empty objects.
+         */
+        Volumes: Record<string, unknown>;
+        /**
+         * The working directory for commands to run in.
+         */
+        WorkingDir: string;
+        /**
+         * The entry point for the container as a string or an array of strings.
+         * If the array consists of exactly one empty string ([""]),
+         * then the entry point is reset to system default
+         * (i.e., the entry point used by docker when there is no ENTRYPOINT instruction in the Dockerfile).
+         */
+        Entrypoint: string[];
+        /**
+         * Disable networking for the container.
+         */
+        NetworkDisabled: boolean | null;
+        /**
+         * `ONBUILD` metadata that were defined in the image's Dockerfile.
+         */
+        OnBuild: string[] | null;
+        /**
+         * User-defined key/value metadata.
+         */
+        Labels: Record<string, string>;
+        /**
+         * Signal to stop a container as a string or unsigned integer.
+         */
+        StopSignal: string | number | null;
+        /**
+         * Timeout to stop a container in seconds.
+         * Default: 10
+         */
+        StopTimeout: number;
+        /**
+         * Shell for when RUN, CMD, and ENTRYPOINT uses a shell.
+         */
+        Shell: string[];
+    }
+}
+declare module "modules/images/index" {
+    import { BaseModule } from "modules/base/index";
+    import type { BuildCacheDiskUsage, BuildImageOptions, CommitBody, CommitParams, CreateImageInfo, ExportAllImagesOptions, ExportImageOptions, HistoryImageOptions, ImageDeleteResponseItem, ImageHistoryResponseItem, ImageID, ImageInspect, ImagePruneResponse, ImageSearchResponseItem, ImageSummary, InspectImageOptions, ListImagesOptions, LoadImageOptions, PruneBuildCacheOptions, PruneImagesOptions, PullImageOptions, PushImageInfo, PushImageOptions, RemoveImageOptions, SearchImagesOptions, TagImageOptions } from "modules/images/types";
+    /**
+     * Images Module - handles all Docker image operations
+     */
+    export class ImagesModule extends BaseModule {
+        /**
+         * List images
+         * @param options - List options
+         * @returns Array of image summaries
+         */
+        list(options?: ListImagesOptions): Promise<ImageSummary[]>;
+        /**
+         * Create (pull) an image
+         * @param options - Pull options
+         * @returns Image creation info
+         */
+        pull(options: PullImageOptions): Promise<CreateImageInfo[]>;
+        /**
+         * Inspect an image
+         * @param name - Image name or ID
+         * @param options - Inspect options
+         * @returns Detailed image information
+         */
+        inspect(name: string, options?: InspectImageOptions): Promise<ImageInspect>;
+        /**
+         * Get image history
+         * @param name - Image name or ID
+         * @param options - History options
+         * @returns Array of image history items
+         */
+        history(name: string, options?: HistoryImageOptions): Promise<ImageHistoryResponseItem[]>;
+        /**
+         * Push an image
+         * @param name - Image name to push
+         * @param options - Push options
+         * @returns Push info
+         */
+        push(name: string, options: PushImageOptions): Promise<PushImageInfo[]>;
+        /**
+         * Tag an image
+         * @param name - Image name or ID to tag
+         * @param options - Tag options
+         */
+        tag(name: string, options: TagImageOptions): Promise<void>;
+        /**
+         * Remove an image
+         * @param name - Image name or ID
+         * @param options - Remove options
+         * @returns Array of delete response items
+         */
+        remove(name: string, options?: RemoveImageOptions): Promise<ImageDeleteResponseItem[]>;
+        /**
+         * Search images
+         * @param options - Search options
+         * @returns Array of search results
+         */
+        search(options: SearchImagesOptions): Promise<ImageSearchResponseItem[]>;
+        /**
+         * Prune unused images
+         * @param options - Prune options
+         * @returns Prune response
+         */
+        prune(options?: PruneImagesOptions): Promise<ImagePruneResponse>;
+        /**
+         * Export an image
+         * @param name - Image name or ID
+         * @param options - Export options
+         * @returns Response with tarball
+         */
+        get(name: string, options?: ExportImageOptions): Promise<Response>;
+        /**
+         * Export multiple images
+         * @param options - Export options
+         * @returns Response with tarball
+         */
+        getAll(options?: ExportAllImagesOptions): Promise<Response>;
+        /**
+         * Load images
+         * @param options - Load options
+         * @returns Load response
+         */
+        load(options: LoadImageOptions): Promise<unknown>;
+        /**
+         * Build an image from a tar archive with a Dockerfile in it.
+         * The Dockerfile specifies how the image is built from the tar archive.
+         * It is typically in the archive's root,
+         * but can be at a different path or have a different name by specifying the dockerfile parameter.
+         * See the Dockerfile reference for more information.
+         *
+         * The Docker daemon performs a preliminary validation of the Dockerfile before starting the build,
+         * and returns an error if the syntax is incorrect.
+         * After that, each instruction is run one-by-one until the ID of the new image is output.
+         *
+         * The build is canceled if the client drops the connection by quitting or being killed.
+         * @param options - Build options
+         * @returns Build info
+         */
+        build(options: BuildImageOptions): Promise<boolean>;
+        /**
+         * Prune build cache
+         * @param options - Prune build cache options
+         * @returns Build cache disk usage
+         */
+        pruneBuild(options?: PruneBuildCacheOptions): Promise<BuildCacheDiskUsage>;
+        /**
+         * Commit a container as an image
+         * @param container - Container ID or name
+         * @param options - Commit options
+         * @returns Image ID
+         */
+        commit(containerConfig: CommitBody, options: CommitParams): Promise<ImageID>;
+    }
+}
+declare module "modules/networks/types" {
+    /**
+     * Network configuration and state
+     */
+    export interface Network {
+        Name?: string;
+        Id?: string;
+        Created?: number;
+        Scope?: string;
+        Driver?: string;
+        EnableIPv4?: boolean;
+        EnableIPv6?: boolean;
+        IPAM?: IPAM;
+        Internal?: boolean;
+        Attachable?: boolean;
+        Ingress?: boolean;
+        ConfigFrom?: ConfigReference;
+        ConfigOnly?: boolean;
+        Options?: Record<string, string>;
+        Labels?: Record<string, string>;
+        Peers?: PeerInfo[];
+    }
+    /**
+     * Network summary (extends Network)
+     */
+    export interface NetworkSummary extends Network {
+    }
+    /**
+     * Full network inspection details
+     */
+    export interface NetworkInspect extends Network {
+        Containers?: Record<string, EndpointResource>;
+        Services?: Record<string, ServiceInfo>;
+        Status?: NetworkStatus;
+    }
+    /**
+     * Network status information
+     */
+    export interface NetworkStatus {
+        IPAM?: IPAMStatus;
+    }
+    /**
+     * Service information in a network
+     */
+    export interface ServiceInfo {
+        VIP?: string;
+        Ports?: string[];
+        LocalLBIndex?: number;
+        Tasks?: NetworkTaskInfo[];
+    }
+    /**
+     * Task information in a network
+     */
+    export interface NetworkTaskInfo {
+        Name?: string;
+        EndpointID?: string;
+        EndpointIP?: string;
+        MacAddress?: string;
+        IPv4Address?: string;
+        IPv6Address?: string;
+    }
+    /**
+     * Config reference for network
+     */
+    export interface ConfigReference {
+        Network?: string;
+    }
+    /**
+     * IPAM configuration
+     */
+    export interface IPAM {
+        Driver?: string;
+        Config?: IPAMConfig[];
+        Options?: Record<string, string>;
+    }
+    /**
+     * IPAM configuration entry
+     */
+    export interface IPAMConfig {
+        Subnet?: string;
+        IPRange?: string;
+        Gateway?: string;
+        AuxiliaryAddresses?: Record<string, string>;
+    }
+    /**
+     * IPAM status
+     */
+    export interface IPAMStatus {
+        Subnets?: Record<string, SubnetStatus>;
+    }
+    /**
+     * Subnet status
+     */
+    export interface SubnetStatus {
+        IPsInUse?: number;
+        DynamicIPsAvailable?: number;
+    }
+    /**
+     * Endpoint resource information
+     */
+    export interface EndpointResource {
+        Name?: string;
+        EndpointID?: string;
+        MacAddress?: string;
+        IPv4Address?: string;
+        IPv6Address?: string;
+    }
+    /**
+     * Peer information
+     */
+    export interface PeerInfo {
+        Name?: string;
+        IP?: string;
+    }
+    /**
+     * Network create response
+     */
+    export interface NetworkCreateResponse {
+        Id?: string;
+        Warning?: string;
+    }
+    /**
+     * Network connect request
+     */
+    export interface NetworkConnectRequest {
+        Container?: string;
+        EndpointConfig?: EndpointSettings;
+    }
+    /**
+     * Network disconnect request
+     */
+    export interface NetworkDisconnectRequest {
+        Container?: string;
+        Force?: boolean;
+    }
+    /**
+     * Endpoint settings
+     */
+    export interface EndpointSettings {
+        IPAMConfig?: EndpointIPAMConfig;
+        Links?: string[];
+        Aliases?: string[];
+        NetworkID?: string;
+        EndpointID?: string;
+        Gateway?: string;
+        IPAddress?: string;
+        IPPrefixLen?: number;
+        IPv6Gateway?: string;
+        GlobalIPv6Address?: string;
+        GlobalIPv6PrefixLen?: number;
+        MacAddress?: string;
+        DriverOpts?: Record<string, string>;
+    }
+    /**
+     * Endpoint IPAM configuration
+     */
+    export interface EndpointIPAMConfig {
+        IPv4Address?: string;
+        IPv6Address?: string;
+        LinkLocalIPs?: string[];
+    }
+    /**
+     * Network prune response
+     */
+    export interface NetworkPruneResponse {
+        NetworksDeleted?: string[];
+    }
+    /**
+     * List networks options
+     */
+    export interface ListNetworksOptions {
+        filters?: {
+            dangling?: boolean[];
+            driver?: string[];
+            id?: string[];
+            label?: string[];
+            name?: string[];
+            scope?: string[];
+            type?: string[];
+        };
+    }
+    /**
+     * Create network options
+     */
+    export interface CreateNetworkOptions {
+        Name: string;
+        CheckDuplicate?: boolean;
+        Driver?: string;
+        Internal?: boolean;
+        Attachable?: boolean;
+        Ingress?: boolean;
+        IPAM?: IPAM;
+        EnableIPv6?: boolean;
+        Options?: Record<string, string>;
+        Labels?: Record<string, string>;
+        Scope?: string;
+    }
+    /**
+     * Inspect network options
+     */
+    export interface InspectNetworkOptions {
+        verbose?: boolean;
+        scope?: string;
+    }
+    /**
+     * Connect network options
+     */
+    export interface ConnectNetworkOptions {
+        Container?: string;
+        EndpointConfig?: EndpointSettings;
+    }
+    /**
+     * Disconnect network options
+     */
+    export interface DisconnectNetworkOptions {
+        Container?: string;
+        Force?: boolean;
+    }
+    /**
+     * Prune networks options
+     */
+    export interface PruneNetworksOptions {
+        filters?: {
+            dangling?: boolean[];
+            label?: string[];
+            until?: string[];
+        };
+    }
+}
+declare module "modules/networks/index" {
+    import { BaseModule } from "modules/base/index";
+    import type { CreateNetworkOptions, ListNetworksOptions, NetworkConnectRequest, NetworkCreateResponse, NetworkDisconnectRequest, NetworkInspect, NetworkPruneResponse, NetworkSummary, PruneNetworksOptions } from "modules/networks/types";
+    /**
+     * Networks module for managing Docker networks
+     */
+    export class NetworksModule extends BaseModule {
+        /**
+         * List networks
+         * @param options - List options including filters
+         * @returns Array of network summaries
+         */
+        list(options?: ListNetworksOptions): Promise<NetworkSummary[]>;
+        /**
+         * Create a network
+         * @param config - Network configuration
+         * @returns Network create response with ID and warnings
+         */
+        create(config: CreateNetworkOptions): Promise<NetworkCreateResponse>;
+        /**
+         * Inspect a network
+         * @param id - Network ID or name
+         * @param options - Inspect options
+         * @returns Detailed network information
+         */
+        inspect(id: string, options?: {
+            verbose?: boolean;
+            scope?: string;
+        }): Promise<NetworkInspect>;
+        /**
+         * Remove a network
+         * @param id - Network ID or name
+         */
+        remove(id: string): Promise<void>;
+        /**
+         * Connect a container to a network
+         * @param id - Network ID or name
+         * @param request - Connection request with container and endpoint config
+         */
+        connect(id: string, request: NetworkConnectRequest): Promise<void>;
+        /**
+         * Disconnect a container from a network
+         * @param id - Network ID or name
+         * @param request - Disconnection request with container and force option
+         */
+        disconnect(id: string, request: NetworkDisconnectRequest): Promise<void>;
+        /**
+         * Remove unused networks
+         * @param options - Prune options including filters
+         * @returns Prune response with deleted networks
+         */
+        prune(options?: PruneNetworksOptions): Promise<NetworkPruneResponse>;
+    }
+}
+declare module "modules/nodes/types" {
+    type NodeFilters = {
+        id?: string[];
+        label?: string[];
+        membership?: Array<"accepted" | "pending">;
+        name?: string[];
+        "node.label"?: string[];
+        role?: Array<"manager" | "worker">;
+    };
+    export type ListNodesOptions = {
+        filters: NodeFilters;
+    };
+    export type NodeResponse = {
+        ID: string;
+        Version: {
+            Index: number;
+        };
+        CreatedAt: string;
+        UpdatedAt: string;
+        Spec: {
+            Name: string;
+            Labels: Record<string, string>;
+            Role: "worker" | "manager";
+            Availability: "active" | "pause" | "drain";
+        };
+        Description: {
+            Hostname: string;
+            Platform: {
+                Architecture: string;
+                OS: string;
+            };
+            Resources: {
+                NanoCPUs: number;
+                MemoryBytes: number;
+                GenericResources: Array<{
+                    DiscreteResourceSpec: {
+                        Kind: string;
+                        Value: number;
+                    };
+                } | {
+                    NamedResourceSpec: {
+                        Kind: string;
+                        Value: string;
+                    };
+                }>;
+            };
+            Engine: {
+                EngineVersion: string;
+                Labels: Record<string, string>;
+                Plugins: Array<{
+                    Type: string;
+                    Name: string;
+                }>;
+            };
+            TLSInfo: {
+                TrustRoot: string;
+                CertIssuerSubject: string;
+                CertIssuerPublicKey: string;
+            };
+        };
+        Status: {
+            State: "unknown" | "down" | "ready" | "disconnected";
+            Message: string;
+            Addr: string;
+        };
+        ManagerStatus: {
+            Leader: boolean;
+            Reachability: "unknown" | "unreachable" | "reachable";
+            Addr: string;
+        } | null;
+    };
+    export type NodeUpdateOptions = {
+        Name: string;
+        Labels: Record<string, string>;
+        Role: "worker" | "manager";
+        Availability: "active" | "pause" | "drain";
+    };
+}
+declare module "modules/nodes/index" {
+    import { BaseModule } from "modules/base/index";
+    import type { ListNodesOptions, NodeResponse, NodeUpdateOptions } from "modules/nodes/types";
+    export class NodesModule extends BaseModule {
+        /**
+         * List nodes
+         * @param options Filters to process on the nodes list, encoded as JSON (a Record<string, string[]>).
+         * @returns NodeResponse[]
+         */
+        list(options?: ListNodesOptions): Promise<NodeResponse[]>;
+        /**
+         * Inspect a node
+         * @param id The ID or name of the node
+         */
+        inspect(id: string): Promise<NodeResponse>;
+        /**
+         *
+         * @param id The ID or name of the node
+         * @param force Force remove a node from the swarm (Default: false)
+         * @returns `true` or throws an DockerError
+         */
+        delete(id: string, force?: boolean): Promise<boolean>;
+        /**
+         *
+         * @param id The ID or name of the node
+         * @param version The version number of the node object being updated. This is required to avoid conflicting writes.
+         * @param options What to update
+         * @returns
+         */
+        update(id: string, version: number, options: NodeUpdateOptions): Promise<boolean>;
+    }
+}
+declare module "modules/volumes/types" {
+    /**
+     * Volume information
+     */
+    export interface Volume {
+        Name: string;
+        Driver: string;
+        Mountpoint: string;
+        CreatedAt?: string;
+        Status?: Record<string, string>;
+        Labels: Record<string, string>;
+        Scope: "local" | "global";
+        ClusterVolume?: ClusterVolume;
+        Options?: Record<string, string>;
+        UsageData?: VolumeUsageData;
+    }
+    /**
+     * Volume usage data
+     */
+    export interface VolumeUsageData {
+        Size: number;
+        RefCount: number;
+    }
+    /**
+     * Volumes disk usage information
+     */
+    export interface VolumesDiskUsage {
+        ActiveCount: number;
+        TotalCount: number;
+        Reclaimable: number;
+        TotalSize: number;
+        Items?: Volume[];
+    }
+    /**
+     * Volume create request
+     */
+    export interface VolumeCreateRequest {
+        Name?: string;
+        Driver?: string;
+        DriverOpts?: Record<string, string>;
+        Labels?: Record<string, string>;
+        ClusterVolumeSpec?: ClusterVolumeSpec;
+    }
+    /**
+     * Volume list response
+     */
+    export interface VolumeListResponse {
+        Volumes: Volume[];
+        Warnings?: string[];
+    }
+    /**
+     * Volume prune response
+     */
+    export interface VolumePruneResponse {
+        VolumesDeleted?: string[];
+        SpaceReclaimed: number;
+    }
+    /**
+     * Cluster volume information (Swarm CSI cluster volumes)
+     */
+    export interface ClusterVolume {
+        ID?: string;
+        Version?: ObjectVersion;
+        CreatedAt?: string;
+        UpdatedAt?: string;
+        Spec?: ClusterVolumeSpec;
+        Info?: ClusterVolumeInfo;
+        PublishStatus?: ClusterVolumePublishStatus[];
+    }
+    /**
+     * Object version
+     */
+    export interface ObjectVersion {
+        Index: number;
+    }
+    /**
+     * Cluster volume spec
+     */
+    export interface ClusterVolumeSpec {
+        Group?: string;
+        AccessMode?: ClusterVolumeAccessMode;
+        Secrets?: ClusterVolumeSecret[];
+        AccessibilityRequirements?: ClusterVolumeAccessibilityRequirements;
+        CapacityRange?: ClusterVolumeCapacityRange;
+        Availability?: "active" | "pause" | "drain";
+    }
+    /**
+     * Cluster volume access mode
+     */
+    export interface ClusterVolumeAccessMode {
+        Scope: "single" | "multi";
+        Sharing: "none" | "readonly" | "onewriter" | "all";
+        MountVolume?: ClusterVolumeMountVolume;
+        BlockVolume?: ClusterVolumeBlockVolume;
+    }
+    /**
+     * Cluster volume mount volume options
+     */
+    export interface ClusterVolumeMountVolume {
+        FsType?: string;
+        MountFlags?: string[];
+    }
+    /**
+     * Cluster volume block volume options
+     */
+    export interface ClusterVolumeBlockVolume {
+        [key: string]: string;
+    }
+    /**
+     * Cluster volume secret
+     */
+    export interface ClusterVolumeSecret {
+        Key: string;
+        Secret: string;
+    }
+    /**
+     * Cluster volume accessibility requirements
+     */
+    export interface ClusterVolumeAccessibilityRequirements {
+        Requisite?: Topology[];
+        Preferred?: Topology[];
+    }
+    /**
+     * Cluster volume capacity range
+     */
+    export interface ClusterVolumeCapacityRange {
+        RequiredBytes?: number;
+        LimitBytes?: number;
+    }
+    /**
+     * Cluster volume info
+     */
+    export interface ClusterVolumeInfo {
+        CapacityBytes?: number;
+        VolumeContext?: Record<string, string>;
+        VolumeID?: string;
+        AccessibleTopology?: Topology[];
+    }
+    /**
+     * Cluster volume publish status
+     */
+    export interface ClusterVolumePublishStatus {
+        NodeID: string;
+        State: "pending-publish" | "published" | "pending-node-unpublish" | "pending-controller-unpublish";
+        PublishContext?: Record<string, string>;
+    }
+    /**
+     * Topology information
+     */
+    export interface Topology {
+        [key: string]: string;
+    }
+    /**
+     * List volumes options
+     */
+    export interface ListVolumesOptions {
+        filters?: {
+            dangling?: boolean[];
+            driver?: string[];
+            label?: string[];
+            name?: string[];
+        };
+    }
+    /**
+     * Prune volumes options
+     */
+    export interface PruneVolumesOptions {
+        filters?: {
+            label?: string[];
+            all?: boolean[];
+        };
+    }
+    /**
+     * Volume update request (for cluster volumes)
+     */
+    export interface VolumeUpdateRequest {
+        Spec: ClusterVolumeSpec;
+    }
+}
+declare module "modules/volumes/index" {
+    import { BaseModule } from "modules/base/index";
+    import type { ListVolumesOptions, PruneVolumesOptions, Volume, VolumeCreateRequest, VolumeListResponse, VolumePruneResponse, VolumeUpdateRequest } from "modules/volumes/types";
+    /**
+     * Volume module for Docker API
+     */
+    export class VolumeModule extends BaseModule {
+        /**
+         * List volumes
+         */
+        list(options?: ListVolumesOptions): Promise<VolumeListResponse>;
+        /**
+         * Create a volume
+         */
+        create(config: VolumeCreateRequest): Promise<Volume>;
+        /**
+         * Inspect a volume
+         */
+        inspect(name: string): Promise<Volume>;
+        /**
+         * Update a volume (for cluster volumes only)
+         */
+        update(name: string, body: VolumeUpdateRequest, version: number): Promise<void>;
+        /**
+         * Remove a volume
+         */
+        remove(name: string, force?: boolean): Promise<void>;
+        /**
+         * Prune unused volumes
+         */
+        prune(options?: PruneVolumesOptions): Promise<VolumePruneResponse>;
+    }
+}
+declare module "docker" {
+    import type { ConnectionConfig } from "modules/base/types";
+    import { ContainerModule } from "modules/container/index";
+    import { DistributionModule } from "modules/distribution/index";
+    import { ExecModule } from "modules/exec/index";
+    import { ImagesModule } from "modules/images/index";
+    import { NetworksModule } from "modules/networks/index";
+    import { NodesModule } from "modules/nodes/index";
+    import { VolumeModule } from "modules/volumes/index";
+    export class Docker {
+        private config;
+        readonly containers: ContainerModule;
+        readonly images: ImagesModule;
+        readonly networks: NetworksModule;
+        readonly volumes: VolumeModule;
+        readonly exec: ExecModule;
+        readonly distribution: DistributionModule;
+        readonly nodes: NodesModule;
+        constructor(config: ConnectionConfig);
+        ping(): Promise<boolean>;
+    }
+}
+declare module "utils/env" {
+    import type { ConnectionConfig } from "modules/base/types";
+    export const getConnectionConfig: () => ConnectionConfig;
+}
+declare module "index" {
+    import { Docker } from "docker";
+    export const createDockerFromEnv: () => Docker;
+    export { Docker };
+}