@otterdeploy/docker 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,2011 @@
+import * as http from "node:http";
+import * as better_result0 from "better-result";
+import { Result } from "better-result";
+import { Client } from "ssh2";
+import { Duplex, PassThrough } from "node:stream";
+import { EventEmitter } from "node:events";
+import * as net from "node:net";
+
+//#region src/errors.d.ts
+declare const DockerBadRequestError_base: better_result0.TaggedErrorClass<"DockerBadRequestError", {
+  message: string;
+}>;
+declare class DockerBadRequestError extends DockerBadRequestError_base {
+  readonly statusCode: 400;
+}
+declare const DockerUnauthorizedError_base: better_result0.TaggedErrorClass<"DockerUnauthorizedError", {
+  message: string;
+}>;
+declare class DockerUnauthorizedError extends DockerUnauthorizedError_base {
+  readonly statusCode: 401;
+}
+declare const DockerForbiddenError_base: better_result0.TaggedErrorClass<"DockerForbiddenError", {
+  message: string;
+}>;
+declare class DockerForbiddenError extends DockerForbiddenError_base {
+  readonly statusCode: 403;
+}
+declare const DockerNotFoundError_base: better_result0.TaggedErrorClass<"DockerNotFoundError", {
+  message: string;
+}>;
+declare class DockerNotFoundError extends DockerNotFoundError_base {
+  readonly statusCode: 404;
+}
+declare const DockerConflictError_base: better_result0.TaggedErrorClass<"DockerConflictError", {
+  message: string;
+}>;
+declare class DockerConflictError extends DockerConflictError_base {
+  readonly statusCode: 409;
+}
+declare const DockerServerError_base: better_result0.TaggedErrorClass<"DockerServerError", {
+  message: string;
+}>;
+declare class DockerServerError extends DockerServerError_base {
+  readonly statusCode: 500;
+}
+declare const DockerServiceUnavailableError_base: better_result0.TaggedErrorClass<"DockerServiceUnavailableError", {
+  message: string;
+}>;
+declare class DockerServiceUnavailableError extends DockerServiceUnavailableError_base {
+  readonly statusCode: 503;
+}
+declare const DockerNetworkError_base: better_result0.TaggedErrorClass<"DockerNetworkError", {
+  message: string;
+  cause: unknown;
+}>;
+declare class DockerNetworkError extends DockerNetworkError_base {}
+declare const DockerTimeoutError_base: better_result0.TaggedErrorClass<"DockerTimeoutError", {
+  message: string;
+  timeoutMs: number;
+}>;
+declare class DockerTimeoutError extends DockerTimeoutError_base {}
+declare const DockerAbortError_base: better_result0.TaggedErrorClass<"DockerAbortError", {
+  message: string;
+}>;
+declare class DockerAbortError extends DockerAbortError_base {}
+declare const DockerDecodeError_base: better_result0.TaggedErrorClass<"DockerDecodeError", {
+  message: string;
+  cause: unknown;
+  body: string;
+}>;
+declare class DockerDecodeError extends DockerDecodeError_base {}
+declare const DockerUnknownError_base: better_result0.TaggedErrorClass<"DockerUnknownError", {
+  message: string;
+  statusCode: number;
+}>;
+declare class DockerUnknownError extends DockerUnknownError_base {}
+type DockerApiError = DockerBadRequestError | DockerUnauthorizedError | DockerForbiddenError | DockerNotFoundError | DockerConflictError | DockerServerError | DockerServiceUnavailableError;
+type DockerTransportError = DockerNetworkError | DockerTimeoutError | DockerAbortError | DockerDecodeError;
+type DockerError = DockerApiError | DockerTransportError | DockerUnknownError;
+/**
+ * Maps an HTTP status code to the appropriate Docker error class.
+ * Unknown status codes produce a DockerUnknownError.
+ */
+declare function statusCodeToError(statusCode: number, message: string): DockerApiError | DockerUnknownError;
+//#endregion
+//#region src/transport/types.d.ts
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "HEAD";
+type StatusCodeMap = Record<number, true | string>;
+type DialOptions = {
+  method: HttpMethod;
+  path: string;
+  query?: Record<string, unknown>;
+  body?: unknown;
+  headers?: Record<string, string>;
+  statusCodes: StatusCodeMap;
+  timeout?: number;
+  signal?: AbortSignal;
+  isStream?: boolean;
+  hijack?: boolean;
+  openStdin?: boolean;
+  authconfig?: Record<string, unknown>;
+  registryconfig?: Record<string, unknown>;
+};
+type DialResponse = {
+  statusCode: number;
+  headers: Record<string, string>;
+  body: unknown;
+};
+type TlsConfig = {
+  ca?: string;
+  cert?: string;
+  key?: string;
+  rejectUnauthorized?: boolean;
+};
+type TransportConfig = {
+  type: "unix";
+  socketPath?: string;
+} | {
+  type: "tcp";
+  host: string;
+  port?: number;
+  tls?: TlsConfig;
+} | {
+  type: "ssh";
+  host: string;
+  port?: number;
+  username: string;
+  privateKey?: string;
+  passphrase?: string;
+} | {
+  type: "npipe";
+  path?: string;
+};
+interface Transport {
+  dial(options: DialOptions): Promise<Result<DialResponse, DockerError>>;
+  dialStream(options: DialOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  dialHijack(options: DialOptions): Promise<Result<net.Socket, DockerError>>;
+  destroy(): void;
+}
+//#endregion
+//#region src/client/types.d.ts
+/** Authentication configuration for registry access. */
+type AuthConfig = {
+  username?: string;
+  password?: string;
+  serveraddress?: string;
+  identitytoken?: string;
+  email?: string;
+};
+/** Response from a prune operation. */
+type PruneResponse = {
+  SpaceReclaimed: number;
+  [key: string]: unknown;
+};
+/** Filters for list/prune operations, mapping filter name to values. */
+type Filters = Record<string, string[]>;
+/**
+ * EventMessage represents the information an event contains.
+ * Returned by the /events endpoint.
+ */
+type EventMessage = {
+  Type?: string;
+  Action?: string;
+  Actor?: EventActor;
+  scope?: string;
+  time?: number;
+  timeNano?: number;
+};
+/** Actor describes something that generates events. */
+type EventActor = {
+  ID?: string;
+  Attributes?: Record<string, string>;
+};
+/** Response to an API call that returns just an Id. */
+type IdResponse = {
+  Id: string;
+  Warnings?: string[];
+};
+/** Response from GET /info. */
+type DockerInfo = {
+  ID: string;
+  Containers: number;
+  ContainersRunning: number;
+  ContainersPaused: number;
+  ContainersStopped: number;
+  Images: number;
+  Driver: string;
+  DriverStatus?: string[][];
+  DockerRootDir?: string;
+  MemTotal: number;
+  MemoryLimit?: boolean;
+  Name: string;
+  NCPU: number;
+  OperatingSystem: string;
+  OSType: string;
+  OSVersion?: string;
+  Architecture: string;
+  ServerVersion: string;
+  KernelVersion?: string;
+  Labels?: string[];
+  ExperimentalBuild?: boolean;
+  Swarm?: Record<string, unknown>;
+  LiveRestoreEnabled?: boolean;
+  SecurityOptions?: string[];
+  Runtimes?: Record<string, unknown>;
+  DefaultRuntime?: string;
+  [key: string]: unknown;
+};
+/** Response from GET /version. */
+type DockerVersion = {
+  Version: string;
+  ApiVersion: string;
+  MinAPIVersion: string;
+  GitCommit: string;
+  GoVersion: string;
+  Os: string;
+  Arch: string;
+  KernelVersion: string;
+  BuildTime: string;
+  Platform?: {
+    Name: string;
+  };
+  Components?: Array<{
+    Name: string;
+    Version: string;
+    Details?: Record<string, unknown> | null;
+  }>;
+  Experimental?: boolean;
+  [key: string]: unknown;
+};
+/** Response from GET /system/df. */
+type SystemDf = {
+  LayersSize: number;
+  Images: ImageSummary[];
+  Containers: ContainerSummary[];
+  Volumes: Volume[];
+  BuildCache?: unknown[];
+  [key: string]: unknown;
+};
+/** Describes a port mapping between the container and the host (list endpoint). */
+type Port = {
+  IP?: string;
+  PrivatePort: number;
+  PublicPort?: number;
+  Type: string;
+};
+/** Represents a binding between a host IP address and a host port. */
+type PortBinding = {
+  HostIp?: string;
+  HostPort?: string;
+};
+/** Mount represents a mount configuration. */
+type Mount = {
+  Target?: string;
+  Source?: string;
+  Type?: string;
+  ReadOnly?: boolean;
+  Consistency?: string;
+  BindOptions?: {
+    Propagation?: string;
+    NonRecursive?: boolean;
+    CreateMountpoint?: boolean;
+    ReadOnlyNonRecursive?: boolean;
+    ReadOnlyForceRecursive?: boolean;
+  };
+  VolumeOptions?: {
+    NoCopy?: boolean;
+    Labels?: Record<string, string>;
+    DriverConfig?: {
+      Name?: string;
+      Options?: Record<string, string>;
+    };
+    Subpath?: string;
+  };
+  TmpfsOptions?: {
+    SizeBytes?: number;
+    Mode?: number;
+    Options?: string[][];
+  };
+  ImageOptions?: {
+    Subpath?: string;
+  };
+};
+/** MountPoint as reported by container inspect (actual mount state). */
+type MountPoint = {
+  Type?: string;
+  Name?: string;
+  Source?: string;
+  Destination?: string;
+  Driver?: string;
+  Mode?: string;
+  RW?: boolean;
+  Propagation?: string;
+};
+/** The behavior to apply when the container exits. */
+type RestartPolicy = {
+  Name?: "" | "no" | "always" | "unless-stopped" | "on-failure";
+  MaximumRetryCount?: number;
+};
+/** Configuration for a network endpoint. */
+type EndpointSettings = {
+  IPAMConfig?: EndpointIPAMConfig | null;
+  Links?: string[];
+  MacAddress?: string;
+  Aliases?: string[];
+  DriverOpts?: Record<string, string> | null;
+  GwPriority?: number;
+  NetworkID?: string;
+  EndpointID?: string;
+  Gateway?: string;
+  IPAddress?: string;
+  IPPrefixLen?: number;
+  IPv6Gateway?: string;
+  GlobalIPv6Address?: string;
+  GlobalIPv6PrefixLen?: number;
+  DNSNames?: string[];
+};
+/** Endpoint IPAM configuration. */
+type EndpointIPAMConfig = {
+  IPv4Address?: string;
+  IPv6Address?: string;
+  LinkLocalIPs?: string[];
+};
+/** NetworkSettings exposes the network settings in the API. */
+type NetworkSettings = {
+  SandboxID?: string;
+  SandboxKey?: string;
+  Ports?: Record<string, PortBinding[] | null>;
+  Networks?: Record<string, EndpointSettings>;
+  Bridge?: string;
+  HairpinMode?: boolean;
+  LinkLocalIPv6Address?: string;
+  LinkLocalIPv6PrefixLen?: number;
+  Gateway?: string;
+  GlobalIPv6Address?: string;
+  GlobalIPv6PrefixLen?: number;
+  IPAddress?: string;
+  IPPrefixLen?: number;
+  IPv6Gateway?: string;
+  MacAddress?: string;
+  [key: string]: unknown;
+};
+/**
+ * NetworkingConfig represents the container's networking configuration
+ * for each of its interfaces. Used in container create.
+ */
+type NetworkingConfig = {
+  EndpointsConfig?: Record<string, EndpointSettings>;
+};
+/** Summary representation of a container (from list endpoint). */
+type ContainerSummary = {
+  Id: string;
+  Names: string[];
+  Image: string;
+  ImageID: string;
+  Command: string;
+  Created: number;
+  State: string;
+  Status: string;
+  Ports: Port[];
+  Labels: Record<string, string>;
+  SizeRw?: number;
+  SizeRootFs?: number;
+  HostConfig: {
+    NetworkMode: string;
+    Annotations?: Record<string, string> | null;
+  };
+  NetworkSettings: {
+    Networks: Record<string, EndpointSettings>;
+  };
+  Mounts: MountPoint[];
+  Health?: {
+    Status?: string;
+    FailingStreak?: number;
+  };
+};
+/** Full container inspection response. */
+type ContainerInspect = {
+  Id: string;
+  Created: string;
+  Path: string;
+  Args: string[];
+  State: ContainerState;
+  Image: string;
+  ResolvConfPath?: string;
+  HostnamePath?: string;
+  HostsPath?: string;
+  LogPath?: string | null;
+  Name: string;
+  RestartCount: number;
+  Driver: string;
+  Platform: string;
+  MountLabel?: string;
+  ProcessLabel?: string;
+  AppArmorProfile?: string;
+  ExecIDs?: string[] | null;
+  HostConfig: HostConfig;
+  GraphDriver?: {
+    Name: string;
+    Data: Record<string, string>;
+  } | null;
+  SizeRw?: number | null;
+  SizeRootFs?: number | null;
+  Config: ContainerConfig;
+  NetworkSettings: NetworkSettings;
+  Mounts: MountPoint[];
+  [key: string]: unknown;
+};
+/** ContainerState stores a container's running state. */
+type ContainerState = {
+  Status: string;
+  Running: boolean;
+  Paused: boolean;
+  Restarting: boolean;
+  OOMKilled: boolean;
+  Dead: boolean;
+  Pid: number;
+  ExitCode: number;
+  Error: string;
+  StartedAt: string;
+  FinishedAt: string;
+  Health?: {
+    Status?: string;
+    FailingStreak?: number;
+    Log?: Array<{
+      Start?: string;
+      End?: string;
+      ExitCode?: number;
+      Output?: string;
+    }>;
+  };
+};
+/** Container configuration (image-level config stored at creation time). */
+type ContainerConfig = {
+  Hostname: string;
+  Domainname: string;
+  User: string;
+  AttachStdin: boolean;
+  AttachStdout: boolean;
+  AttachStderr: boolean;
+  ExposedPorts?: Record<string, {}>;
+  Tty: boolean;
+  OpenStdin: boolean;
+  StdinOnce: boolean;
+  Env: string[];
+  Cmd: string[];
+  Image: string;
+  Volumes?: Record<string, {}>;
+  WorkingDir: string;
+  Entrypoint: string[] | null;
+  Labels: Record<string, string>;
+  OnBuild?: string[] | null;
+  StopSignal?: string;
+  StopTimeout?: number;
+  Healthcheck?: HealthConfig;
+  [key: string]: unknown;
+};
+/** Health check configuration. */
+type HealthConfig = {
+  Test?: string[];
+  Interval?: number;
+  Timeout?: number;
+  Retries?: number;
+  StartPeriod?: number;
+  StartInterval?: number;
+};
+/** Host-specific configuration for a container. */
+type HostConfig = {
+  Binds?: string[];
+  Memory?: number;
+  MemorySwap?: number;
+  MemoryReservation?: number;
+  NanoCpus?: number;
+  CpuShares?: number;
+  CpuPeriod?: number;
+  CpuQuota?: number;
+  CpusetCpus?: string;
+  CpusetMems?: string;
+  CpuCount?: number;
+  CpuPercent?: number;
+  BlkioWeight?: number;
+  BlkioWeightDevice?: Array<{
+    Path: string;
+    Weight: number;
+  }>;
+  BlkioDeviceReadBps?: Array<{
+    Path: string;
+    Rate: number;
+  }>;
+  BlkioDeviceWriteBps?: Array<{
+    Path: string;
+    Rate: number;
+  }>;
+  BlkioDeviceReadIOps?: Array<{
+    Path: string;
+    Rate: number;
+  }>;
+  BlkioDeviceWriteIOps?: Array<{
+    Path: string;
+    Rate: number;
+  }>;
+  NetworkMode?: string;
+  PortBindings?: Record<string, PortBinding[]>;
+  RestartPolicy?: RestartPolicy;
+  Privileged?: boolean;
+  PublishAllPorts?: boolean;
+  ReadonlyRootfs?: boolean;
+  Dns?: string[];
+  DnsOptions?: string[];
+  DnsSearch?: string[];
+  ExtraHosts?: string[];
+  VolumesFrom?: string[];
+  Mounts?: Mount[];
+  CapAdd?: string[];
+  CapDrop?: string[];
+  GroupAdd?: string[];
+  SecurityOpt?: string[];
+  UsernsMode?: string;
+  Sysctls?: Record<string, string>;
+  Runtime?: string;
+  Isolation?: string;
+  MaskedPaths?: string[];
+  ReadonlyPaths?: string[];
+  LogConfig?: {
+    Type: string;
+    Config: Record<string, string>;
+  };
+  CgroupnsMode?: string;
+  CgroupParent?: string;
+  PidsLimit?: number | null;
+  OomKillDisable?: boolean;
+  OomScoreAdj?: number;
+  ShmSize?: number;
+  Tmpfs?: Record<string, string>;
+  UTSMode?: string;
+  IpcMode?: string;
+  PidMode?: string;
+  Devices?: Array<{
+    PathOnHost?: string;
+    PathInContainer?: string;
+    CgroupPermissions?: string;
+  }>;
+  DeviceRequests?: Array<{
+    Driver?: string;
+    Count?: number;
+    DeviceIDs?: string[];
+    Capabilities?: string[][];
+    Options?: Record<string, string>;
+  }>;
+  DeviceCgroupRules?: string[];
+  Ulimits?: Array<{
+    Name?: string;
+    Soft?: number;
+    Hard?: number;
+  }>;
+  Init?: boolean | null;
+  Links?: string[];
+  AutoRemove?: boolean;
+  StorageOpt?: Record<string, string>;
+  Annotations?: Record<string, string>;
+  [key: string]: unknown;
+};
+/** Options for creating a container. */
+type CreateContainerOptions = {
+  name?: string;
+  platform?: string;
+  Image: string;
+  Cmd?: string[];
+  Env?: string[];
+  ExposedPorts?: Record<string, {}>;
+  HostConfig?: Partial<HostConfig>;
+  Labels?: Record<string, string>;
+  Volumes?: Record<string, {}>;
+  WorkingDir?: string;
+  Entrypoint?: string[] | null;
+  Tty?: boolean;
+  OpenStdin?: boolean;
+  StdinOnce?: boolean;
+  AttachStdin?: boolean;
+  AttachStdout?: boolean;
+  AttachStderr?: boolean;
+  User?: string;
+  NetworkingConfig?: NetworkingConfig;
+  StopSignal?: string;
+  StopTimeout?: number;
+  Domainname?: string;
+  Hostname?: string;
+  Healthcheck?: HealthConfig;
+  OnBuild?: string[];
+  Shell?: string[];
+  MacAddress?: string;
+  [key: string]: unknown;
+};
+/** Response from container create. */
+type CreateContainerResponse = {
+  Id: string;
+  Warnings: string[];
+};
+/** Response from container wait. */
+type WaitResponse = {
+  StatusCode: number;
+  Error?: {
+    Message: string;
+  };
+};
+/** Filesystem change in a container. */
+type ContainerChange = {
+  Path: string;
+  Kind: number;
+};
+/** Container top (process list) response. */
+type ContainerTopResponse = {
+  Titles: string[];
+  Processes: string[][];
+};
+/** Container update response. */
+type ContainerUpdateResponse = {
+  Warnings?: string[];
+};
+/**
+ * Container stats response.
+ * Uses Record<string, unknown> with key fields typed due to the large
+ * and platform-dependent shape of the stats response.
+ */
+type ContainerStats = {
+  id?: string;
+  name?: string;
+  read?: string;
+  preread?: string;
+  num_procs?: number;
+  cpu_stats?: {
+    cpu_usage?: {
+      total_usage?: number;
+      percpu_usage?: number[] | null;
+      usage_in_kernelmode?: number;
+      usage_in_usermode?: number;
+    };
+    system_cpu_usage?: number;
+    online_cpus?: number;
+    throttling_data?: {
+      periods?: number;
+      throttled_periods?: number;
+      throttled_time?: number;
+    };
+    [key: string]: unknown;
+  };
+  precpu_stats?: {
+    cpu_usage?: {
+      total_usage?: number;
+      percpu_usage?: number[] | null;
+      usage_in_kernelmode?: number;
+      usage_in_usermode?: number;
+    };
+    system_cpu_usage?: number;
+    online_cpus?: number;
+    throttling_data?: {
+      periods?: number;
+      throttled_periods?: number;
+      throttled_time?: number;
+    };
+    [key: string]: unknown;
+  };
+  memory_stats?: {
+    usage?: number;
+    max_usage?: number;
+    limit?: number;
+    stats?: Record<string, unknown>;
+    [key: string]: unknown;
+  };
+  pids_stats?: {
+    current?: number;
+    limit?: number;
+  };
+  blkio_stats?: {
+    io_service_bytes_recursive?: Array<{
+      major?: number;
+      minor?: number;
+      op?: string;
+      value?: number;
+    }> | null;
+    [key: string]: unknown;
+  };
+  networks?: Record<string, {
+    rx_bytes?: number;
+    rx_packets?: number;
+    rx_errors?: number;
+    rx_dropped?: number;
+    tx_bytes?: number;
+    tx_packets?: number;
+    tx_errors?: number;
+    tx_dropped?: number;
+    [key: string]: unknown;
+  }>;
+  storage_stats?: Record<string, unknown>;
+  [key: string]: unknown;
+};
+/** Options for container logs. */
+type LogsOptions = {
+  follow?: boolean;
+  stdout?: boolean;
+  stderr?: boolean;
+  since?: number;
+  until?: number;
+  timestamps?: boolean;
+  tail?: string;
+};
+/** Summary representation of an image (from list endpoint). */
+type ImageSummary = {
+  Id: string;
+  ParentId: string;
+  RepoTags: string[];
+  RepoDigests: string[];
+  Created: number;
+  Size: number;
+  SharedSize: number;
+  Labels: Record<string, string>;
+  Containers: number;
+  Manifests?: unknown[];
+  Descriptor?: Record<string, unknown> | null;
+  [key: string]: unknown;
+};
+/** Full image inspection response. */
+type ImageInspect = {
+  Id: string;
+  RepoTags?: string[];
+  RepoDigests?: string[];
+  Comment?: string | null;
+  Created?: string | null;
+  Author?: string | null;
+  Config?: ImageConfig;
+  Architecture: string;
+  Variant?: string | null;
+  Os: string;
+  OsVersion?: string | null;
+  Size: number;
+  GraphDriver?: {
+    Name: string;
+    Data: Record<string, string>;
+  } | null;
+  RootFS?: {
+    Type: string;
+    Layers?: string[];
+  };
+  Metadata?: {
+    LastTagTime?: string | null;
+  };
+  Descriptor?: Record<string, unknown> | null;
+  Manifests?: unknown[] | null;
+  Identity?: Record<string, unknown> | null;
+  [key: string]: unknown;
+};
+/** Image configuration (stored in the image manifest). */
+type ImageConfig = {
+  Hostname?: string;
+  Domainname?: string;
+  User?: string;
+  AttachStdin?: boolean;
+  AttachStdout?: boolean;
+  AttachStderr?: boolean;
+  ExposedPorts?: Record<string, {}>;
+  Tty?: boolean;
+  OpenStdin?: boolean;
+  StdinOnce?: boolean;
+  Env?: string[];
+  Cmd?: string[] | null;
+  Image?: string;
+  Volumes?: Record<string, {}> | null;
+  WorkingDir?: string;
+  Entrypoint?: string[] | null;
+  Labels?: Record<string, string>;
+  OnBuild?: string[] | null;
+  StopSignal?: string;
+  Healthcheck?: HealthConfig;
+  Shell?: string[] | null;
+  [key: string]: unknown;
+};
+/** Individual image layer information from image history. */
+type ImageHistory = {
+  Id: string;
+  Created: number;
+  CreatedBy: string;
+  Tags: string[];
+  Size: number;
+  Comment: string;
+};
+/** Options for creating/pulling an image. */
+type CreateImageOptions = {
+  fromImage?: string;
+  fromSrc?: string;
+  repo?: string;
+  tag?: string;
+  platform?: string;
+  [key: string]: unknown;
+};
+/** Result from image search. */
+type SearchResult = {
+  description?: string;
+  is_official?: boolean;
+  is_automated?: boolean;
+  name?: string;
+  star_count?: number;
+};
+/** Options for building an image. */
+type BuildOptions = {
+  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?: Record<string, string>;
+  shmsize?: number;
+  squash?: boolean;
+  labels?: Record<string, string>;
+  networkmode?: string;
+  platform?: string;
+  target?: string;
+  outputs?: string;
+  version?: string;
+  [key: string]: unknown;
+};
+/** Response item from image delete. */
+type ImageDeleteResponseItem = {
+  Untagged?: string;
+  Deleted?: string;
+};
+/** Options for importing an image from a tar archive. */
+type ImageImportOptions = {
+  repo?: string;
+  tag?: string;
+  message?: string;
+  platform?: string;
+  [key: string]: unknown;
+};
+/** Options for pruning build cache. */
+type BuilderPruneOptions = {
+  "keep-storage"?: number;
+  all?: boolean;
+  filters?: Filters;
+};
+/** Response from build cache prune. */
+type BuilderPruneResponse = {
+  CachesDeleted?: string[];
+  SpaceReclaimed: number;
+};
+/** Options for creating a checkpoint. */
+type CheckpointCreateOptions = {
+  CheckpointID: string;
+  Exit?: boolean;
+};
+/** Archive info returned by HEAD /containers/{id}/archive. */
+type ArchiveInfo = {
+  name: string;
+  size: number;
+  mode: number;
+  mtime: string;
+  linkTarget: string;
+};
+/** A Docker volume. */
+type Volume = {
+  Name: string;
+  Driver: string;
+  Mountpoint: string;
+  CreatedAt?: string;
+  Status?: Record<string, unknown>;
+  Labels: Record<string, string>;
+  Scope: string;
+  Options: Record<string, string>;
+  UsageData?: {
+    Size: number;
+    RefCount: number;
+  } | null;
+  ClusterVolume?: Record<string, unknown>;
+  [key: string]: unknown;
+};
+/** Response from volume list. */
+type VolumeListResponse = {
+  Volumes: Volume[];
+  Warnings?: string[];
+};
+/** Options for creating a volume. */
+type CreateVolumeOptions = {
+  Name?: string;
+  Driver?: string;
+  DriverOpts?: Record<string, string>;
+  Labels?: Record<string, string>;
+  ClusterVolumeSpec?: Record<string, unknown>;
+};
+/** A Docker network. */
+type Network = {
+  Name: string;
+  Id: string;
+  Created: string;
+  Scope: string;
+  Driver: string;
+  EnableIPv4?: boolean;
+  EnableIPv6?: boolean;
+  IPAM?: IPAM;
+  Internal?: boolean;
+  Attachable?: boolean;
+  Ingress?: boolean;
+  ConfigFrom?: {
+    Network?: string;
+  };
+  ConfigOnly?: boolean;
+  Options?: Record<string, string>;
+  Labels?: Record<string, string>;
+  Peers?: Array<{
+    Name?: string;
+    IP?: string;
+  }>;
+  Containers?: Record<string, {
+    Name?: string;
+    EndpointID?: string;
+    MacAddress?: string;
+    IPv4Address?: string;
+    IPv6Address?: string;
+  }>;
+  Services?: Record<string, unknown>;
+  [key: string]: unknown;
+};
+/** IPAM configuration for a network. */
+type IPAM = {
+  Driver?: string;
+  Config?: Array<{
+    Subnet?: string;
+    IPRange?: string;
+    Gateway?: string;
+    AuxiliaryAddresses?: Record<string, string>;
+  }>;
+  Options?: Record<string, string>;
+};
+/** Options for creating a network. */
+type NetworkCreateOptions = {
+  Name: string;
+  Driver?: string;
+  Scope?: string;
+  Internal?: boolean;
+  Attachable?: boolean;
+  Ingress?: boolean;
+  ConfigOnly?: boolean;
+  ConfigFrom?: {
+    Network?: string;
+  };
+  IPAM?: IPAM;
+  EnableIPv4?: boolean;
+  EnableIPv6?: boolean;
+  Options?: Record<string, string>;
+  Labels?: Record<string, string>;
+};
+/** Response from network create. */
+type NetworkCreateResponse = {
+  Id: string;
+  Warning: string;
+};
+/** Options for connecting a container to a network. */
+type NetworkConnectOptions = {
+  Container: string;
+  EndpointConfig?: EndpointSettings | null;
+};
+/** Options for disconnecting a container from a network. */
+type NetworkDisconnectOptions = {
+  Container: string;
+  Force?: boolean;
+};
+/** Options for creating an exec instance. */
+type 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;
+};
+/** Inspection response for an exec instance. */
+type ExecInspect = {
+  CanRemove?: boolean;
+  DetachKeys?: string;
+  ID?: string;
+  Running?: boolean;
+  ExitCode?: number;
+  ProcessConfig?: {
+    privileged?: boolean;
+    user?: string;
+    tty?: boolean;
+    entrypoint?: string;
+    arguments?: string[];
+  };
+  OpenStdin?: boolean;
+  OpenStderr?: boolean;
+  OpenStdout?: boolean;
+  ContainerID?: string;
+  Pid?: number;
+};
+/** Options for starting an exec instance. */
+type ExecStartOptions = {
+  Detach?: boolean;
+  Tty?: boolean;
+  ConsoleSize?: [number, number] | null;
+};
+/** A Docker Swarm service. */
+type Service = {
+  ID?: string;
+  Version?: ObjectVersion;
+  CreatedAt?: string;
+  UpdatedAt?: string;
+  Spec?: ServiceSpec;
+  Endpoint?: {
+    Spec?: EndpointSpec;
+    Ports?: EndpointPortConfig[];
+    VirtualIPs?: Array<{
+      NetworkID?: string;
+      Addr?: string;
+    }>;
+  };
+  UpdateStatus?: {
+    State?: string;
+    StartedAt?: string;
+    CompletedAt?: string;
+    Message?: string;
+  };
+  ServiceStatus?: {
+    RunningTasks?: number;
+    DesiredTasks?: number;
+    CompletedTasks?: number;
+  };
+  JobStatus?: {
+    JobIteration?: ObjectVersion;
+    LastExecution?: string;
+  };
+  [key: string]: unknown;
+};
+/** Version number for optimistic concurrency control. */
+type ObjectVersion = {
+  Index?: number;
+};
+/** User-modifiable configuration for a service. */
+type ServiceSpec = {
+  Name?: string;
+  Labels?: Record<string, string>;
+  TaskTemplate?: Record<string, unknown>;
+  Mode?: {
+    Replicated?: {
+      Replicas?: number;
+    };
+    Global?: {};
+    ReplicatedJob?: {
+      MaxConcurrent?: number;
+      TotalCompletions?: number;
+    };
+    GlobalJob?: {};
+  };
+  UpdateConfig?: ServiceUpdateConfig;
+  RollbackConfig?: ServiceUpdateConfig;
+  Networks?: Array<{
+    Target?: string;
+    Aliases?: string[];
+  }>;
+  EndpointSpec?: EndpointSpec;
+  [key: string]: unknown;
+};
+/** Update/rollback configuration for a service. */
+type ServiceUpdateConfig = {
+  Parallelism?: number;
+  Delay?: number;
+  FailureAction?: string;
+  Monitor?: number;
+  MaxFailureRatio?: number;
+  Order?: string;
+};
+/** Endpoint specification for a service. */
+type EndpointSpec = {
+  Mode?: string;
+  Ports?: EndpointPortConfig[];
+};
+/** Port configuration for a service endpoint. */
+type EndpointPortConfig = {
+  Name?: string;
+  Protocol?: string;
+  TargetPort?: number;
+  PublishedPort?: number;
+  PublishMode?: string;
+};
+/** Options for creating a service. */
+type ServiceCreateOptions = {
+  Name?: string;
+  Labels?: Record<string, string>;
+  TaskTemplate?: Record<string, unknown>;
+  Mode?: ServiceSpec["Mode"];
+  UpdateConfig?: ServiceUpdateConfig;
+  RollbackConfig?: ServiceUpdateConfig;
+  Networks?: Array<{
+    Target?: string;
+    Aliases?: string[];
+  }>;
+  EndpointSpec?: EndpointSpec;
+  authconfig?: AuthConfig;
+  [key: string]: unknown;
+};
+/** Response from service create. */
+type ServiceCreateResponse = {
+  ID: string;
+  Warnings?: string[] | null;
+};
+/** Options for updating a service. */
+type ServiceUpdateOptions = {
+  version: number;
+  Name?: string;
+  Labels?: Record<string, string>;
+  TaskTemplate?: Record<string, unknown>;
+  Mode?: ServiceSpec["Mode"];
+  UpdateConfig?: ServiceUpdateConfig;
+  RollbackConfig?: ServiceUpdateConfig;
+  Networks?: Array<{
+    Target?: string;
+    Aliases?: string[];
+  }>;
+  EndpointSpec?: EndpointSpec;
+  authconfig?: AuthConfig;
+  registryAuthFrom?: string;
+  rollback?: string;
+  [key: string]: unknown;
+};
+/** Response from service update. */
+type ServiceUpdateResponse = {
+  Warnings?: string[];
+};
+/** A Swarm task. */
+type Task = {
+  ID?: string;
+  Version?: ObjectVersion;
+  CreatedAt?: string;
+  UpdatedAt?: string;
+  Name?: string;
+  Labels?: Record<string, string>;
+  Spec?: Record<string, unknown>;
+  ServiceID?: string;
+  Slot?: number;
+  NodeID?: string;
+  AssignedGenericResources?: unknown[];
+  Status?: {
+    Timestamp?: string;
+    State?: string;
+    Message?: string;
+    Err?: string;
+    ContainerStatus?: {
+      ContainerID?: string;
+      PID?: number;
+      ExitCode?: number;
+    };
+    PortStatus?: {
+      Ports?: EndpointPortConfig[];
+    };
+  };
+  DesiredState?: string;
+  JobIteration?: ObjectVersion;
+  [key: string]: unknown;
+};
+/** A Swarm node. */
+type Node = {
+  ID?: string;
+  Version?: ObjectVersion;
+  CreatedAt?: string;
+  UpdatedAt?: string;
+  Spec?: NodeSpec;
+  Description?: {
+    Hostname?: string;
+    Platform?: {
+      Architecture?: string;
+      OS?: string;
+    };
+    Resources?: {
+      NanoCPUs?: number;
+      MemoryBytes?: number;
+      GenericResources?: unknown[];
+    };
+    Engine?: {
+      EngineVersion?: string;
+      Labels?: Record<string, string>;
+      Plugins?: Array<{
+        Type?: string;
+        Name?: string;
+      }>;
+    };
+    TLSInfo?: {
+      TrustRoot?: string;
+      CertIssuerSubject?: string;
+      CertIssuerPublicKey?: string;
+    };
+  };
+  Status?: {
+    State?: string;
+    Message?: string;
+    Addr?: string;
+  };
+  ManagerStatus?: {
+    Leader?: boolean;
+    Reachability?: string;
+    Addr?: string;
+  } | null;
+  [key: string]: unknown;
+};
+/** Node specification (user-modifiable fields). */
+type NodeSpec = {
+  Name?: string;
+  Labels?: Record<string, string>;
+  Role?: "worker" | "manager";
+  Availability?: "active" | "pause" | "drain";
+};
+/** A Swarm secret. */
+type Secret = {
+  ID?: string;
+  Version?: ObjectVersion;
+  CreatedAt?: string;
+  UpdatedAt?: string;
+  Spec?: SecretSpec;
+  [key: string]: unknown;
+};
+/** Secret specification. */
+type SecretSpec = {
+  Name?: string;
+  Labels?: Record<string, string>;
+  Data?: string;
+  Driver?: {
+    Name: string;
+    Options?: Record<string, string>;
+  };
+  Templating?: {
+    Name: string;
+    Options?: Record<string, string>;
+  };
+};
+/** Options for creating a secret. */
+type SecretCreateOptions = {
+  Name: string;
+  Labels?: Record<string, string>;
+  Data: string;
+  Driver?: {
+    Name: string;
+    Options?: Record<string, string>;
+  };
+  Templating?: {
+    Name: string;
+    Options?: Record<string, string>;
+  };
+};
+/** A Swarm config object. */
+type Config = {
+  ID?: string;
+  Version?: ObjectVersion;
+  CreatedAt?: string;
+  UpdatedAt?: string;
+  Spec?: ConfigSpec;
+  [key: string]: unknown;
+};
+/** Config specification. */
+type ConfigSpec = {
+  Name?: string;
+  Labels?: Record<string, string>;
+  Data?: string;
+  Templating?: {
+    Name: string;
+    Options?: Record<string, string>;
+  };
+};
+/** Options for creating a config. */
+type ConfigCreateOptions = {
+  Name: string;
+  Labels?: Record<string, string>;
+  Data: string;
+  Templating?: {
+    Name: string;
+    Options?: Record<string, string>;
+  };
+};
+/** Response from POST /auth. */
+type AuthResponse = {
+  Status: string;
+  IdentityToken?: string;
+};
+/** Options for initializing a swarm. */
+type SwarmInitOptions = {
+  ListenAddr: string;
+  AdvertiseAddr?: string;
+  DataPathAddr?: string;
+  DataPathPort?: number;
+  ForceNewCluster?: boolean;
+  Spec?: Record<string, unknown>;
+  DefaultAddrPool?: string[];
+  SubnetSize?: number;
+  [key: string]: unknown;
+};
+/** Options for joining a swarm. */
+type SwarmJoinOptions = {
+  ListenAddr: string;
+  AdvertiseAddr?: string;
+  DataPathAddr?: string;
+  RemoteAddrs: string[];
+  JoinToken: string;
+  [key: string]: unknown;
+};
+/** Options for leaving a swarm. */
+type SwarmLeaveOptions = {
+  force?: boolean;
+};
+/** Options for updating a swarm. */
+type SwarmUpdateOptions = {
+  version: number;
+  rotateWorkerToken?: boolean;
+  rotateManagerToken?: boolean;
+  rotateManagerUnlockKey?: boolean;
+  Spec?: Record<string, unknown>;
+  [key: string]: unknown;
+};
+/** Options for the events endpoint. */
+type EventsOptions = {
+  since?: string;
+  until?: string;
+  filters?: Record<string, string[]>;
+};
+/** A Docker plugin. */
+type Plugin = {
+  Id?: string;
+  Name: string;
+  Enabled: boolean;
+  Settings: {
+    Mounts: Array<Record<string, unknown>>;
+    Env: string[];
+    Args: string[];
+    Devices: Array<Record<string, unknown>>;
+  };
+  PluginReference?: string;
+  Config: {
+    Description: string;
+    Documentation: string;
+    Interface: {
+      Types: string[];
+      Socket: string;
+      ProtocolScheme?: string;
+    };
+    Entrypoint: string[];
+    WorkDir: string;
+    User?: {
+      UID?: number;
+      GID?: number;
+    };
+    Network: {
+      Type: string;
+    };
+    Linux: {
+      Capabilities: string[];
+      AllowAllDevices: boolean;
+      Devices: Array<Record<string, unknown>>;
+    };
+    PropagatedMount: string;
+    IpcHost: boolean;
+    PidHost: boolean;
+    Mounts: Array<Record<string, unknown>>;
+    Env: Array<Record<string, unknown>>;
+    Args: {
+      Name: string;
+      Description: string;
+      Settable: string[];
+      Value: string[];
+    };
+    rootfs?: {
+      type?: string;
+      diff_ids?: string[];
+    };
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+};
+/** Describes a permission the user has to accept upon installing a plugin. */
+type PluginPrivilege = {
+  Name?: string;
+  Description?: string;
+  Value?: string[];
+};
+//#endregion
+//#region src/client/system.d.ts
+declare class SystemOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  ping(): Promise<Result<string, DockerError>>;
+  info(): Promise<Result<DockerInfo, DockerError>>;
+  version(): Promise<Result<DockerVersion, DockerError>>;
+  df(): Promise<Result<SystemDf, DockerError>>;
+  swarmInit(options: SwarmInitOptions): Promise<Result<string, DockerError>>;
+  swarmJoin(options: SwarmJoinOptions): Promise<Result<void, DockerError>>;
+  swarmLeave(options?: SwarmLeaveOptions): Promise<Result<void, DockerError>>;
+  swarmUpdate(options: SwarmUpdateOptions): Promise<Result<void, DockerError>>;
+  swarmInspect(): Promise<Result<unknown, DockerError>>;
+  events(options?: EventsOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  auth(options: AuthConfig): Promise<Result<AuthResponse, DockerError>>;
+  pruneBuilder(options?: BuilderPruneOptions): Promise<Result<BuilderPruneResponse, DockerError>>;
+}
+//#endregion
+//#region src/client/exec.d.ts
+type ExecStartWithStdinOptions = ExecStartOptions & {
+  stdin?: boolean;
+};
+declare class Exec {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly id: string;
+  constructor(transport: Transport, apiVersion: string, id: string);
+  start(options?: ExecStartWithStdinOptions): Promise<Result<NodeJS.ReadableStream | Duplex, DockerError>>;
+  resize(options: {
+    h: number;
+    w: number;
+  }): Promise<Result<void, DockerError>>;
+  inspect(): Promise<Result<ExecInspect, DockerError>>;
+}
+//#endregion
+//#region src/client/container.d.ts
+type ContainerListOptions = {
+  all?: boolean;
+  limit?: number;
+  size?: boolean;
+  filters?: Filters;
+};
+type ContainerStopOptions = {
+  t?: number;
+};
+type ContainerRestartOptions = {
+  t?: number;
+};
+type ContainerKillOptions = {
+  signal?: string;
+};
+type ContainerRemoveOptions = {
+  v?: boolean;
+  force?: boolean;
+  link?: boolean;
+};
+type ContainerWaitOptions = {
+  condition?: "not-running" | "next-exit" | "removed";
+};
+type ContainerResizeOptions = {
+  h: number;
+  w: number;
+};
+type ContainerAttachOptions = {
+  detachKeys?: string;
+  logs?: boolean;
+  stream?: boolean;
+  stdin?: boolean;
+  stdout?: boolean;
+  stderr?: boolean;
+};
+type ContainerStatsOptions = {
+  stream?: boolean;
+  "one-shot"?: boolean;
+};
+type ContainerArchiveOptions = {
+  path: string;
+};
+type ContainerPruneOptions = {
+  filters?: Filters;
+};
+type ContainerCommitOptions = {
+  repo?: string;
+  tag?: string;
+  comment?: string;
+  author?: string;
+  pause?: boolean;
+  changes?: string;
+  [key: string]: unknown;
+};
+type ContainerUpdateOptions = {
+  Memory?: number;
+  MemorySwap?: number;
+  MemoryReservation?: number;
+  NanoCpus?: number;
+  CpuShares?: number;
+  CpuPeriod?: number;
+  CpuQuota?: number;
+  CpusetCpus?: string;
+  CpusetMems?: string;
+  BlkioWeight?: number;
+  RestartPolicy?: {
+    Name?: string;
+    MaximumRetryCount?: number;
+  };
+  PidsLimit?: number;
+  [key: string]: unknown;
+};
+declare class Container {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly id: string;
+  constructor(transport: Transport, apiVersion: string, id: string);
+  inspect(): Promise<Result<ContainerInspect, DockerError>>;
+  start(): Promise<Result<void, DockerError>>;
+  stop(options?: ContainerStopOptions): Promise<Result<void, DockerError>>;
+  restart(options?: ContainerRestartOptions): Promise<Result<void, DockerError>>;
+  kill(options?: ContainerKillOptions): Promise<Result<void, DockerError>>;
+  pause(): Promise<Result<void, DockerError>>;
+  unpause(): Promise<Result<void, DockerError>>;
+  remove(options?: ContainerRemoveOptions): Promise<Result<void, DockerError>>;
+  rename(name: string): Promise<Result<void, DockerError>>;
+  update(options: ContainerUpdateOptions): Promise<Result<ContainerUpdateResponse, DockerError>>;
+  top(psArgs?: string): Promise<Result<ContainerTopResponse, DockerError>>;
+  changes(): Promise<Result<ContainerChange[], DockerError>>;
+  logs(options?: LogsOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  stats(options?: ContainerStatsOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  wait(options?: ContainerWaitOptions): Promise<Result<WaitResponse, DockerError>>;
+  resize(options: ContainerResizeOptions): Promise<Result<void, DockerError>>;
+  attach(options?: ContainerAttachOptions): Promise<Result<NodeJS.ReadableStream | Duplex, DockerError>>;
+  exec(options: ExecCreateOptions): Promise<Result<Exec, DockerError>>;
+  export(): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  getArchive(options: ContainerArchiveOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  putArchive(options: ContainerArchiveOptions, stream: NodeJS.ReadableStream): Promise<Result<void, DockerError>>;
+  listCheckpoints(): Promise<Result<unknown[], DockerError>>;
+  createCheckpoint(options: CheckpointCreateOptions): Promise<Result<void, DockerError>>;
+  deleteCheckpoint(name: string): Promise<Result<void, DockerError>>;
+  infoArchive(options: ContainerArchiveOptions): Promise<Result<ArchiveInfo, DockerError>>;
+  commit(options?: ContainerCommitOptions): Promise<Result<IdResponse, DockerError>>;
+}
+declare class ContainerOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  list(options?: ContainerListOptions): Promise<Result<ContainerSummary[], DockerError>>;
+  create(options: CreateContainerOptions): Promise<Result<Container, DockerError>>;
+  inspect(id: string): Promise<Result<ContainerInspect, DockerError>>;
+  prune(options?: ContainerPruneOptions): Promise<Result<PruneResponse, DockerError>>;
+  getContainer(id: string): Container;
+}
+//#endregion
+//#region src/client/image.d.ts
+type ImageListOptions = {
+  all?: boolean;
+  filters?: Filters;
+  digests?: boolean;
+};
+type ImageSearchOptions = {
+  term: string;
+  limit?: number;
+  filters?: Filters;
+};
+type ImagePruneOptions = {
+  filters?: Filters;
+};
+type ImageTagOptions = {
+  repo: string;
+  tag?: string;
+};
+type ImageRemoveOptions = {
+  force?: boolean;
+  noprune?: boolean;
+};
+type ImagePushOptions = {
+  tag?: string;
+};
+declare class Image {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly name: string;
+  constructor(transport: Transport, apiVersion: string, name: string);
+  inspect(): Promise<Result<ImageInspect, DockerError>>;
+  history(): Promise<Result<ImageHistory[], DockerError>>;
+  push(options?: ImagePushOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  tag(options: ImageTagOptions): Promise<Result<void, DockerError>>;
+  remove(options?: ImageRemoveOptions): Promise<Result<ImageDeleteResponseItem[], DockerError>>;
+  get(): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  distribution(): Promise<Result<Record<string, unknown>, DockerError>>;
+}
+declare class ImageOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  list(options?: ImageListOptions): Promise<Result<ImageSummary[], DockerError>>;
+  create(options: CreateImageOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  build(context: NodeJS.ReadableStream | Buffer, options?: BuildOptions & {
+    authconfig?: AuthConfig;
+    registryconfig?: Record<string, AuthConfig>;
+  }): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  load(stream: NodeJS.ReadableStream): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  import(stream: NodeJS.ReadableStream, options?: ImageImportOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  search(options: ImageSearchOptions): Promise<Result<SearchResult[], DockerError>>;
+  prune(options?: ImagePruneOptions): Promise<Result<PruneResponse, DockerError>>;
+  getImage(name: string): Image;
+}
+//#endregion
+//#region src/client/volume.d.ts
+type VolumeListOptions = {
+  filters?: Filters;
+};
+type VolumePruneOptions = {
+  filters?: Filters;
+};
+type VolumeRemoveOptions = {
+  force?: boolean;
+};
+declare class VolumeEntity {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly name: string;
+  constructor(transport: Transport, apiVersion: string, name: string);
+  inspect(): Promise<Result<Volume, DockerError>>;
+  remove(options?: VolumeRemoveOptions): Promise<Result<void, DockerError>>;
+}
+declare class VolumeOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  list(options?: VolumeListOptions): Promise<Result<VolumeListResponse, DockerError>>;
+  create(options: CreateVolumeOptions): Promise<Result<Volume, DockerError>>;
+  inspect(name: string): Promise<Result<Volume, DockerError>>;
+  prune(options?: VolumePruneOptions): Promise<Result<PruneResponse, DockerError>>;
+  getVolume(name: string): VolumeEntity;
+}
+//#endregion
+//#region src/client/network.d.ts
+type NetworkListOptions = {
+  filters?: Filters;
+};
+type NetworkPruneOptions = {
+  filters?: Filters;
+};
+declare class NetworkEntity {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly id: string;
+  constructor(transport: Transport, apiVersion: string, id: string);
+  inspect(): Promise<Result<Network, DockerError>>;
+  remove(): Promise<Result<void, DockerError>>;
+  connect(options: NetworkConnectOptions): Promise<Result<void, DockerError>>;
+  disconnect(options: NetworkDisconnectOptions): Promise<Result<void, DockerError>>;
+}
+declare class NetworkOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  list(options?: NetworkListOptions): Promise<Result<Network[], DockerError>>;
+  create(options: NetworkCreateOptions): Promise<Result<NetworkCreateResponse, DockerError>>;
+  inspect(id: string): Promise<Result<Network, DockerError>>;
+  prune(options?: NetworkPruneOptions): Promise<Result<PruneResponse, DockerError>>;
+  getNetwork(id: string): NetworkEntity;
+}
+//#endregion
+//#region src/client/service.d.ts
+type ServiceListOptions = {
+  filters?: Filters;
+  status?: boolean;
+};
+declare class ServiceEntity {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly id: string;
+  constructor(transport: Transport, apiVersion: string, id: string);
+  inspect(): Promise<Result<Service, DockerError>>;
+  update(options: ServiceUpdateOptions): Promise<Result<void, DockerError>>;
+  remove(): Promise<Result<void, DockerError>>;
+  logs(options?: LogsOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+}
+declare class ServiceOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  list(options?: ServiceListOptions): Promise<Result<Service[], DockerError>>;
+  create(options: ServiceCreateOptions): Promise<Result<ServiceCreateResponse, DockerError>>;
+  inspect(id: string): Promise<Result<Service, DockerError>>;
+  getService(id: string): ServiceEntity;
+}
+//#endregion
+//#region src/client/task.d.ts
+type TaskListOptions = {
+  filters?: Filters;
+};
+declare class TaskEntity {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly id: string;
+  constructor(transport: Transport, apiVersion: string, id: string);
+  inspect(): Promise<Result<Task, DockerError>>;
+  logs(options?: LogsOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+}
+declare class TaskOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  list(options?: TaskListOptions): Promise<Result<Task[], DockerError>>;
+  inspect(id: string): Promise<Result<Task, DockerError>>;
+  getTask(id: string): TaskEntity;
+}
+//#endregion
+//#region src/client/node.d.ts
+type NodeListOptions = {
+  filters?: Filters;
+};
+type NodeUpdateOptions = {
+  version: number;
+  Name?: string;
+  Labels?: Record<string, string>;
+  Role?: NodeSpec["Role"];
+  Availability?: NodeSpec["Availability"];
+};
+type NodeRemoveOptions = {
+  force?: boolean;
+};
+declare class NodeEntity {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly id: string;
+  constructor(transport: Transport, apiVersion: string, id: string);
+  inspect(): Promise<Result<Node, DockerError>>;
+  update(options: NodeUpdateOptions): Promise<Result<void, DockerError>>;
+  remove(options?: NodeRemoveOptions): Promise<Result<void, DockerError>>;
+}
+declare class NodeOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  list(options?: NodeListOptions): Promise<Result<Node[], DockerError>>;
+  inspect(id: string): Promise<Result<Node, DockerError>>;
+  getNode(id: string): NodeEntity;
+}
+//#endregion
+//#region src/client/secret.d.ts
+type SecretListOptions = {
+  filters?: Filters;
+};
+type SecretUpdateOptions = {
+  version: number;
+  Name?: string;
+  Labels?: Record<string, string>;
+  Data?: string;
+  Driver?: {
+    Name: string;
+    Options?: Record<string, string>;
+  };
+  Templating?: {
+    Name: string;
+    Options?: Record<string, string>;
+  };
+};
+declare class SecretEntity {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly id: string;
+  constructor(transport: Transport, apiVersion: string, id: string);
+  inspect(): Promise<Result<Secret, DockerError>>;
+  update(options: SecretUpdateOptions): Promise<Result<void, DockerError>>;
+  remove(): Promise<Result<void, DockerError>>;
+}
+declare class SecretOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  list(options?: SecretListOptions): Promise<Result<Secret[], DockerError>>;
+  create(options: SecretCreateOptions): Promise<Result<IdResponse, DockerError>>;
+  inspect(id: string): Promise<Result<Secret, DockerError>>;
+  getSecret(id: string): SecretEntity;
+}
+//#endregion
+//#region src/client/config.d.ts
+type ConfigListOptions = {
+  filters?: Filters;
+};
+type ConfigUpdateOptions = {
+  version: number;
+  Name?: string;
+  Labels?: Record<string, string>;
+  Data?: string;
+  Templating?: {
+    Name: string;
+    Options?: Record<string, string>;
+  };
+};
+declare class ConfigEntity {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly id: string;
+  constructor(transport: Transport, apiVersion: string, id: string);
+  inspect(): Promise<Result<Config, DockerError>>;
+  update(options: ConfigUpdateOptions): Promise<Result<void, DockerError>>;
+  remove(): Promise<Result<void, DockerError>>;
+}
+declare class ConfigOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  list(options?: ConfigListOptions): Promise<Result<Config[], DockerError>>;
+  create(options: ConfigCreateOptions): Promise<Result<IdResponse, DockerError>>;
+  inspect(id: string): Promise<Result<Config, DockerError>>;
+  getConfig(id: string): ConfigEntity;
+}
+//#endregion
+//#region src/client/plugin.d.ts
+type PluginListOptions = {
+  filters?: Filters;
+};
+type PluginPrivilegesOptions = {
+  remote: string;
+};
+type PluginInstallOptions = {
+  remote: string;
+  name?: string;
+};
+type PluginCreateOptions = {
+  name: string;
+};
+type PluginRemoveOptions = {
+  force?: boolean;
+};
+type PluginEnableOptions = {
+  timeout?: number;
+};
+type PluginDisableOptions = {
+  Force?: boolean;
+};
+type PluginConfigureOptions = {
+  env: string[];
+};
+type PluginUpgradeOptions = {
+  remote: string;
+};
+declare class PluginEntity {
+  private readonly transport;
+  private readonly apiVersion;
+  readonly name: string;
+  constructor(transport: Transport, apiVersion: string, name: string);
+  inspect(): Promise<Result<Plugin, DockerError>>;
+  remove(options?: PluginRemoveOptions): Promise<Result<Plugin, DockerError>>;
+  enable(options?: PluginEnableOptions): Promise<Result<void, DockerError>>;
+  disable(options?: PluginDisableOptions): Promise<Result<void, DockerError>>;
+  push(): Promise<Result<void, DockerError>>;
+  configure(options: PluginConfigureOptions): Promise<Result<void, DockerError>>;
+  upgrade(options: PluginUpgradeOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+}
+declare class PluginOperations {
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(transport: Transport, apiVersion: string);
+  list(options?: PluginListOptions): Promise<Result<Plugin[], DockerError>>;
+  privileges(options: PluginPrivilegesOptions): Promise<Result<PluginPrivilege[], DockerError>>;
+  install(options: PluginInstallOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  create(options: PluginCreateOptions): Promise<Result<void, DockerError>>;
+  getPlugin(name: string): PluginEntity;
+}
+//#endregion
+//#region src/client/index.d.ts
+type DockerConfig = {
+  transport: TransportConfig;
+  apiVersion: string;
+  timeoutMs?: number;
+};
+type PullOptions = {
+  authconfig?: AuthConfig;
+  platform?: string;
+};
+type RunOptions = Omit<CreateContainerOptions, "Image" | "Cmd"> & {
+  autoRemove?: boolean;
+};
+type RunResult = {
+  output: WaitResponse;
+  container: Container;
+};
+declare class Docker {
+  readonly system: SystemOperations;
+  readonly containers: ContainerOperations;
+  readonly images: ImageOperations;
+  readonly volumes: VolumeOperations;
+  readonly networks: NetworkOperations;
+  readonly services: ServiceOperations;
+  readonly tasks: TaskOperations;
+  readonly nodes: NodeOperations;
+  readonly secrets: SecretOperations;
+  readonly configs: ConfigOperations;
+  readonly plugins: PluginOperations;
+  private readonly transport;
+  private readonly apiVersion;
+  constructor(config: DockerConfig);
+  /** Create Docker client with pre-existing transport (for testing). */
+  static fromTransport(transport: Transport, opts: {
+    apiVersion: string;
+  }): Docker;
+  /**
+   * Create Docker client from environment variables.
+   * Reads DOCKER_HOST, DOCKER_TLS_VERIFY, DOCKER_CERT_PATH, DOCKER_CLIENT_TIMEOUT.
+   */
+  static fromEnv(opts?: {
+    apiVersion?: string;
+  }): Docker;
+  /**
+   * Pull an image from a registry.
+   * Returns a progress stream of newline-delimited JSON.
+   */
+  pull(repoTag: string, options?: PullOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  /**
+   * Create and run a container, waiting for it to exit.
+   * Returns the wait result and the container instance.
+   */
+  run(image: string, cmd: string[], options?: RunOptions): Promise<Result<RunResult, DockerError>>;
+  destroy(): void;
+}
+//#endregion
+//#region src/transport/npipe-transport.d.ts
+type RequestFn = typeof http.request;
+type NamedPipeTransportOptions = {
+  path?: string; /** @internal For testing only. Override the http.request function. */
+  _requestFn?: RequestFn;
+};
+declare class NamedPipeTransport implements Transport {
+  private readonly pipePath;
+  private readonly requestFn;
+  constructor(options: NamedPipeTransportOptions);
+  dial(options: DialOptions): Promise<Result<DialResponse, DockerError>>;
+  dialStream(options: DialOptions): Promise<Result<NodeJS.ReadableStream, DockerError>>;
+  dialHijack(options: DialOptions): Promise<Result<net.Socket, DockerError>>;
+  destroy(): void;
+  private performHijack;
+  private performRequest;
+  private convertError;
+}
+//#endregion
+//#region src/transport/index.d.ts
+declare function createTransport(config: TransportConfig): Transport;
+/**
+ * Create a transport by auto-detecting configuration from environment variables.
+ *
+ * Environment variables:
+ * - DOCKER_HOST: Docker daemon socket (unix://, tcp://, ssh://, npipe://)
+ * - DOCKER_TLS_VERIFY: Set to "1" to enable TLS verification
+ * - DOCKER_CERT_PATH: Directory containing ca.pem, cert.pem, key.pem
+ * - DOCKER_CLIENT_TIMEOUT: Default timeout in seconds
+ */
+declare function createTransportFromEnv(): Transport;
+//#endregion
+//#region src/transport/http-duplex.d.ts
+/**
+ * HttpDuplex wraps a raw net.Socket (obtained from HTTP hijack/upgrade)
+ * into a Node.js Duplex stream for bidirectional I/O.
+ *
+ * Used for interactive attach/exec operations where stdin needs to be
+ * written to the connection while stdout/stderr is read from it.
+ */
+declare class HttpDuplex extends Duplex {
+  private readonly socket;
+  constructor(socket: net.Socket);
+  _read(_size: number): void;
+  _write(chunk: Buffer | string, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+}
+//#endregion
+//#region src/transport/stream-utils.d.ts
+declare class DockerStream extends EventEmitter {
+  readonly isTty: boolean;
+  private readonly source;
+  constructor(source: NodeJS.ReadableStream, isTty: boolean);
+  /**
+   * Destroys the underlying source stream.
+   */
+  destroy(): void;
+}
+/**
+ * Separates a Docker multiplexed stream into stdout and stderr PassThrough
+ * streams based on the Docker stream multiplexing protocol.
+ *
+ * Docker multiplexed format: 8-byte header per frame
+ * - Byte 0: stream type (0=stdin, 1=stdout, 2=stderr)
+ * - Bytes 1-3: padding (0)
+ * - Bytes 4-7: payload size (big-endian uint32)
+ * - Followed by `size` bytes of payload
+ */
+declare function demuxStream(source: NodeJS.ReadableStream): {
+  stdout: PassThrough;
+  stderr: PassThrough;
+};
+/**
+ * Follows a newline-delimited JSON progress stream (e.g., from pull/push/build).
+ * Accumulates all events and calls onFinished when the stream ends.
+ * Optionally calls onProgress for each event as it arrives.
+ */
+declare function followProgress(stream: NodeJS.ReadableStream, onFinished: (err: Error | null, output: unknown[]) => void, onProgress?: (event: unknown) => void): void;
+//#endregion
+//#region src/session/index.d.ts
+type SessionResult = {
+  sessionId: string;
+  close: () => void;
+};
+/**
+ * Establishes a BuildKit gRPC session over a hijacked HTTP connection.
+ *
+ * This is used for BuildKit v2 builds to provide registry credentials
+ * to the builder during image builds.
+ */
+declare function withSession(transport: Transport, apiVersion: string, auth?: AuthConfig): Promise<Result<SessionResult, DockerError>>;
+//#endregion
+export { type ArchiveInfo, type AuthConfig, type AuthResponse, type BuildOptions, type BuilderPruneOptions, type BuilderPruneResponse, type CheckpointCreateOptions, type Config, type ConfigCreateOptions, ConfigEntity, type ConfigListOptions, ConfigOperations, type ConfigSpec, type ConfigUpdateOptions, Container, type ContainerArchiveOptions, type ContainerAttachOptions, type ContainerChange, type ContainerCommitOptions, type ContainerConfig, type ContainerInspect, type ContainerKillOptions, type ContainerListOptions, ContainerOperations, type ContainerPruneOptions, type ContainerRemoveOptions, type ContainerResizeOptions, type ContainerRestartOptions, type ContainerState, type ContainerStats, type ContainerStatsOptions, type ContainerStopOptions, type ContainerSummary, type ContainerTopResponse, type ContainerUpdateOptions, type ContainerUpdateResponse, type ContainerWaitOptions, type CreateContainerOptions, type CreateContainerResponse, type CreateImageOptions, type CreateVolumeOptions, type DialOptions, type DialResponse, Docker, DockerAbortError, type DockerApiError, DockerBadRequestError, type DockerConfig, DockerConflictError, DockerDecodeError, type DockerError, DockerForbiddenError, type DockerInfo, DockerNetworkError, DockerNotFoundError, DockerServerError, DockerServiceUnavailableError, DockerStream, DockerTimeoutError, type DockerTransportError, DockerUnauthorizedError, DockerUnknownError, type DockerVersion, type EndpointIPAMConfig, type EndpointPortConfig, type EndpointSettings, type EndpointSpec, type EventActor, type EventMessage, type EventsOptions, Exec, type ExecCreateOptions, type ExecInspect, type ExecStartOptions, type ExecStartWithStdinOptions, type Filters, type HealthConfig, type HostConfig, HttpDuplex, type HttpMethod, type IPAM, type IdResponse, Image, type ImageConfig, type ImageDeleteResponseItem, type ImageHistory, type ImageImportOptions, type ImageInspect, type ImageListOptions, ImageOperations, type ImagePruneOptions, type ImagePushOptions, type ImageRemoveOptions, type ImageSearchOptions, type ImageSummary, type ImageTagOptions, type LogsOptions, type Mount, type MountPoint, NamedPipeTransport, type Network, type NetworkConnectOptions, type NetworkCreateOptions, type NetworkCreateResponse, type NetworkDisconnectOptions, NetworkEntity, type NetworkListOptions, NetworkOperations, type NetworkPruneOptions, type NetworkSettings, type NetworkingConfig, type Node, NodeEntity, type NodeListOptions, NodeOperations, type NodeRemoveOptions, type NodeSpec, type NodeUpdateOptions, type ObjectVersion, type Plugin, type PluginConfigureOptions, type PluginCreateOptions, type PluginDisableOptions, type PluginEnableOptions, PluginEntity, type PluginInstallOptions, type PluginListOptions, PluginOperations, type PluginPrivilege, type PluginPrivilegesOptions, type PluginRemoveOptions, type PluginUpgradeOptions, type Port, type PortBinding, type PruneResponse, type PullOptions, type RestartPolicy, type RunOptions, type RunResult, type SearchResult, type Secret, type SecretCreateOptions, SecretEntity, type SecretListOptions, SecretOperations, type SecretSpec, type SecretUpdateOptions, type Service, type ServiceCreateOptions, type ServiceCreateResponse, ServiceEntity, type ServiceListOptions, ServiceOperations, type ServiceSpec, type ServiceUpdateConfig, type ServiceUpdateOptions, type ServiceUpdateResponse, type SessionResult, type StatusCodeMap, type SwarmInitOptions, type SwarmJoinOptions, type SwarmLeaveOptions, type SwarmUpdateOptions, type SystemDf, SystemOperations, type Task, TaskEntity, type TaskListOptions, TaskOperations, type TlsConfig, type Transport, type TransportConfig, type Volume, VolumeEntity, type VolumeListOptions, type VolumeListResponse, VolumeOperations, type VolumePruneOptions, type VolumeRemoveOptions, type WaitResponse, createTransport, createTransportFromEnv, demuxStream, followProgress, statusCodeToError, withSession };
+//# sourceMappingURL=index.d.mts.map