commands.ts

/**
 * This file was auto generated by @block65/openapi-codegen
 *
 * WARN: Do not edit directly.
 *
 * Generated on 2026-03-17T13:16:20.373Z
 *
 */
/** eslint-disable max-classes */
import { Command, jsonStringify, stripUndefined } from "@block65/rest-client";
import type {
	BuildPruneCommandInput,
	BuildPruneCommandOutput,
	BuildPruneCommandQuery,
	ConfigCreateCommandInput,
	ConfigCreateCommandOutput,
	ConfigDeleteCommandInput,
	ConfigInspectCommandInput,
	ConfigInspectCommandOutput,
	ConfigListCommandInput,
	ConfigListCommandOutput,
	ConfigListCommandQuery,
	ConfigUpdateCommandInput,
	ConfigUpdateCommandQuery,
	ContainerArchiveCommandInput,
	ContainerArchiveCommandQuery,
	ContainerArchiveInfoCommandInput,
	ContainerArchiveInfoCommandQuery,
	ContainerAttachCommandInput,
	ContainerAttachCommandQuery,
	ContainerAttachWebsocketCommandInput,
	ContainerAttachWebsocketCommandQuery,
	ContainerChangesCommandInput,
	ContainerChangesCommandOutput,
	ContainerCreateCommandInput,
	ContainerCreateCommandOutput,
	ContainerCreateCommandQuery,
	ContainerDeleteCommandInput,
	ContainerDeleteCommandQuery,
	ContainerExecCommandInput,
	ContainerExecCommandOutput,
	ContainerExportCommandInput,
	ContainerInspectCommandInput,
	ContainerInspectCommandOutput,
	ContainerInspectCommandQuery,
	ContainerKillCommandInput,
	ContainerKillCommandQuery,
	ContainerListCommandInput,
	ContainerListCommandOutput,
	ContainerListCommandQuery,
	ContainerLogsCommandInput,
	ContainerLogsCommandQuery,
	ContainerPauseCommandInput,
	ContainerPruneCommandInput,
	ContainerPruneCommandOutput,
	ContainerPruneCommandQuery,
	ContainerRenameCommandInput,
	ContainerRenameCommandQuery,
	ContainerResizeCommandInput,
	ContainerResizeCommandQuery,
	ContainerRestartCommandInput,
	ContainerRestartCommandQuery,
	ContainerStartCommandInput,
	ContainerStartCommandQuery,
	ContainerStatsCommandInput,
	ContainerStatsCommandOutput,
	ContainerStatsCommandQuery,
	ContainerStopCommandInput,
	ContainerStopCommandQuery,
	ContainerTopCommandInput,
	ContainerTopCommandOutput,
	ContainerTopCommandQuery,
	ContainerUnpauseCommandInput,
	ContainerUpdateCommandInput,
	ContainerUpdateCommandOutput,
	ContainerWaitCommandInput,
	ContainerWaitCommandOutput,
	ContainerWaitCommandQuery,
	DistributionInspectCommandInput,
	DistributionInspectCommandOutput,
	ExecInspectCommandInput,
	ExecInspectCommandOutput,
	ExecResizeCommandInput,
	ExecResizeCommandQuery,
	ExecStartCommandInput,
	GetPluginPrivilegesCommandInput,
	GetPluginPrivilegesCommandOutput,
	GetPluginPrivilegesCommandQuery,
	ImageBuildCommandInput,
	ImageBuildCommandQuery,
	ImageCommitCommandInput,
	ImageCommitCommandOutput,
	ImageCommitCommandQuery,
	ImageCreateCommandInput,
	ImageCreateCommandQuery,
	ImageDeleteCommandInput,
	ImageDeleteCommandOutput,
	ImageDeleteCommandQuery,
	ImageGetAllCommandInput,
	ImageGetAllCommandQuery,
	ImageGetCommandInput,
	ImageHistoryCommandInput,
	ImageHistoryCommandOutput,
	ImageInspectCommandInput,
	ImageInspectCommandOutput,
	ImageListCommandInput,
	ImageListCommandOutput,
	ImageListCommandQuery,
	ImageLoadCommandInput,
	ImageLoadCommandQuery,
	ImagePruneCommandInput,
	ImagePruneCommandOutput,
	ImagePruneCommandQuery,
	ImagePushCommandInput,
	ImagePushCommandQuery,
	ImageSearchCommandInput,
	ImageSearchCommandOutput,
	ImageSearchCommandQuery,
	ImageTagCommandInput,
	ImageTagCommandQuery,
	NetworkConnectCommandInput,
	NetworkCreateCommandInput,
	NetworkCreateCommandOutput,
	NetworkDeleteCommandInput,
	NetworkDisconnectCommandInput,
	NetworkInspectCommandInput,
	NetworkInspectCommandOutput,
	NetworkInspectCommandQuery,
	NetworkListCommandInput,
	NetworkListCommandOutput,
	NetworkListCommandQuery,
	NetworkPruneCommandInput,
	NetworkPruneCommandOutput,
	NetworkPruneCommandQuery,
	NodeDeleteCommandInput,
	NodeDeleteCommandQuery,
	NodeInspectCommandInput,
	NodeInspectCommandOutput,
	NodeListCommandInput,
	NodeListCommandOutput,
	NodeListCommandQuery,
	NodeUpdateCommandInput,
	NodeUpdateCommandQuery,
	PluginCreateCommandInput,
	PluginCreateCommandQuery,
	PluginDeleteCommandInput,
	PluginDeleteCommandOutput,
	PluginDeleteCommandQuery,
	PluginDisableCommandInput,
	PluginDisableCommandQuery,
	PluginEnableCommandInput,
	PluginEnableCommandQuery,
	PluginInspectCommandInput,
	PluginInspectCommandOutput,
	PluginListCommandInput,
	PluginListCommandOutput,
	PluginListCommandQuery,
	PluginPullCommandInput,
	PluginPullCommandQuery,
	PluginPushCommandInput,
	PluginSetCommandInput,
	PluginUpgradeCommandInput,
	PluginUpgradeCommandQuery,
	PutContainerArchiveCommandInput,
	PutContainerArchiveCommandQuery,
	SecretCreateCommandInput,
	SecretCreateCommandOutput,
	SecretDeleteCommandInput,
	SecretInspectCommandInput,
	SecretInspectCommandOutput,
	SecretListCommandInput,
	SecretListCommandOutput,
	SecretListCommandQuery,
	SecretUpdateCommandInput,
	SecretUpdateCommandQuery,
	ServiceCreateCommandInput,
	ServiceCreateCommandOutput,
	ServiceDeleteCommandInput,
	ServiceInspectCommandInput,
	ServiceInspectCommandOutput,
	ServiceInspectCommandQuery,
	ServiceListCommandInput,
	ServiceListCommandOutput,
	ServiceListCommandQuery,
	ServiceLogsCommandInput,
	ServiceLogsCommandQuery,
	ServiceUpdateCommandInput,
	ServiceUpdateCommandOutput,
	ServiceUpdateCommandQuery,
	SessionCommandInput,
	SwarmInitCommandInput,
	SwarmInitCommandOutput,
	SwarmInspectCommandInput,
	SwarmInspectCommandOutput,
	SwarmJoinCommandInput,
	SwarmLeaveCommandInput,
	SwarmLeaveCommandQuery,
	SwarmUnlockCommandInput,
	SwarmUnlockkeyCommandInput,
	SwarmUnlockkeyCommandOutput,
	SwarmUpdateCommandInput,
	SwarmUpdateCommandQuery,
	SystemAuthCommandInput,
	SystemAuthCommandOutput,
	SystemDataUsageCommandInput,
	SystemDataUsageCommandOutput,
	SystemDataUsageCommandQuery,
	SystemEventsCommandInput,
	SystemEventsCommandOutput,
	SystemEventsCommandQuery,
	SystemInfoCommandInput,
	SystemInfoCommandOutput,
	SystemPingCommandInput,
	SystemPingHeadCommandInput,
	SystemVersionCommandInput,
	SystemVersionCommandOutput,
	TaskInspectCommandInput,
	TaskInspectCommandOutput,
	TaskListCommandInput,
	TaskListCommandOutput,
	TaskListCommandQuery,
	TaskLogsCommandInput,
	TaskLogsCommandQuery,
	VolumeCreateCommandInput,
	VolumeCreateCommandOutput,
	VolumeDeleteCommandInput,
	VolumeDeleteCommandQuery,
	VolumeInspectCommandInput,
	VolumeInspectCommandOutput,
	VolumeListCommandInput,
	VolumeListCommandOutput,
	VolumeListCommandQuery,
	VolumePruneCommandInput,
	VolumePruneCommandOutput,
	VolumePruneCommandQuery,
	VolumeUpdateCommandInput,
	VolumeUpdateCommandQuery,
} from "./types.js";

/**
 * Tagged template literal that applies encodeURIComponent to all interpolated
 * values, protecting path integrity from characters like `/` and `#`.
 * @example encodePath`/users/${userId}` // "/users/foo%2Fbar"
 */
function encodePath(
	strings: TemplateStringsArray,
	...values: string[]
): string {
	return String.raw({ raw: strings }, ...values.map(encodeURIComponent));
}

/**
 * Returns a list of containers. For details on the format, see the
 * [inspect endpoint](#operation/ContainerInspect).
 *
 * Note that it uses a different, smaller representation of a container
 * than inspecting a single container. For example, the list of linked
 * containers is not propagated .
 *
 * @summary List containers
 */
export class ContainerListCommand extends Command<
	ContainerListCommandInput,
	ContainerListCommandOutput,
	ContainerListCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ContainerListCommandInput) {
		const { all, limit, size, filters } = input;
		super(
			"/containers/json",
			undefined,
			stripUndefined({ all, limit, size, filters }),
		);
	}
}

/**
 * ContainerCreateCommand
 *
 * @summary Create a container
 */
export class ContainerCreateCommand extends Command<
	ContainerCreateCommandInput,
	ContainerCreateCommandOutput,
	ContainerCreateCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ContainerCreateCommandInput) {
		const { name, platform, ...body } = input;
		super(
			"/containers/create",
			jsonStringify(body),
			stripUndefined({ name, platform }),
		);
	}
}

/**
 * Return low-level information about a container.
 *
 * @summary Inspect a container
 */
export class ContainerInspectCommand extends Command<
	ContainerInspectCommandInput,
	ContainerInspectCommandOutput,
	ContainerInspectCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ContainerInspectCommandInput) {
		const { id, size } = input;
		super(
			encodePath`/containers/${id}/json`,
			undefined,
			stripUndefined({ size }),
		);
	}
}

/**
 * On Unix systems, this is done by running the `ps` command. This endpoint
 * is not supported on Windows.
 *
 * @summary List processes running inside a container
 */
export class ContainerTopCommand extends Command<
	ContainerTopCommandInput,
	ContainerTopCommandOutput,
	ContainerTopCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ContainerTopCommandInput) {
		const { id, ps_args } = input;
		super(
			encodePath`/containers/${id}/top`,
			undefined,
			stripUndefined({ ps_args }),
		);
	}
}

/**
 * Get `stdout` and `stderr` logs from a container.
 *
 * Note: This endpoint works only for containers with the `json-file` or
 * `journald` logging driver.
 *
 * @summary Get container logs
 */
export class ContainerLogsCommand extends Command<
	ContainerLogsCommandInput,
	unknown,
	ContainerLogsCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ContainerLogsCommandInput) {
		const { id, follow, stdout, stderr, since, until, timestamps, tail } =
			input;
		super(
			encodePath`/containers/${id}/logs`,
			undefined,
			stripUndefined({
				follow,
				stdout,
				stderr,
				since,
				until,
				timestamps,
				tail,
			}),
		);
	}
}

/**
 * Returns which files in a container's filesystem have been added, deleted,
 * or modified. The `Kind` of modification can be one of:
 *
 * - `0`: Modified ("C")
 * - `1`: Added ("A")
 * - `2`: Deleted ("D")
 *
 * @summary Get changes on a container’s filesystem
 */
export class ContainerChangesCommand extends Command<
	ContainerChangesCommandInput,
	ContainerChangesCommandOutput
> {
	public override method = "get" as const;

	constructor(input: ContainerChangesCommandInput) {
		const { id } = input;
		super(encodePath`/containers/${id}/changes`);
	}
}

/**
 * Export the contents of a container as a tarball.
 *
 * @summary Export a container
 */
export class ContainerExportCommand extends Command<
	ContainerExportCommandInput,
	unknown
> {
	public override method = "get" as const;

	constructor(input: ContainerExportCommandInput) {
		const { id } = input;
		super(encodePath`/containers/${id}/export`);
	}
}

/**
 * This endpoint returns a live stream of a container’s resource usage
 * statistics.
 *
 * The `precpu_stats` is the CPU statistic of the *previous* read, and is
 * used to calculate the CPU usage percentage. It is not an exact copy
 * of the `cpu_stats` field.
 *
 * If either `precpu_stats.online_cpus` or `cpu_stats.online_cpus` is
 * nil then for compatibility with older daemons the length of the
 * corresponding `cpu_usage.percpu_usage` array should be used.
 *
 * On a cgroup v2 host, the following fields are not set
 * * `blkio_stats`: all fields other than `io_service_bytes_recursive`
 * * `cpu_stats`: `cpu_usage.percpu_usage`
 * * `memory_stats`: `max_usage` and `failcnt`
 * Also, `memory_stats.stats` fields are incompatible with cgroup v1.
 *
 * To calculate the values shown by the `stats` command of the docker cli tool
 * the following formulas can be used:
 * * used_memory = `memory_stats.usage - memory_stats.stats.cache`
 * * available_memory = `memory_stats.limit`
 * * Memory usage % = `(used_memory / available_memory) * 100.0`
 * * cpu_delta = `cpu_stats.cpu_usage.total_usage -
 * precpu_stats.cpu_usage.total_usage`
 * * system_cpu_delta = `cpu_stats.system_cpu_usage -
 * precpu_stats.system_cpu_usage`
 * * number_cpus = `length(cpu_stats.cpu_usage.percpu_usage)` or
 * `cpu_stats.online_cpus`
 * * CPU usage % = `(cpu_delta / system_cpu_delta) * number_cpus * 100.0`
 *
 * @summary Get container stats based on resource usage
 */
export class ContainerStatsCommand extends Command<
	ContainerStatsCommandInput,
	ContainerStatsCommandOutput,
	ContainerStatsCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ContainerStatsCommandInput) {
		const { id, stream, oneshot } = input;
		super(
			encodePath`/containers/${id}/stats`,
			undefined,
			stripUndefined({ stream, oneshot }),
		);
	}
}

/**
 * Resize the TTY for a container.
 *
 * @summary Resize a container TTY
 */
export class ContainerResizeCommand extends Command<
	ContainerResizeCommandInput,
	unknown,
	ContainerResizeCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ContainerResizeCommandInput) {
		const { id, h, w } = input;
		super(
			encodePath`/containers/${id}/resize`,
			undefined,
			stripUndefined({ h, w }),
		);
	}
}

/**
 * ContainerStartCommand
 *
 * @summary Start a container
 */
export class ContainerStartCommand extends Command<
	ContainerStartCommandInput,
	undefined,
	ContainerStartCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ContainerStartCommandInput) {
		const { id, detachKeys } = input;
		super(
			encodePath`/containers/${id}/start`,
			undefined,
			stripUndefined({ detachKeys }),
		);
	}
}

/**
 * ContainerStopCommand
 *
 * @summary Stop a container
 */
export class ContainerStopCommand extends Command<
	ContainerStopCommandInput,
	undefined,
	ContainerStopCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ContainerStopCommandInput) {
		const { id, signal, t } = input;
		super(
			encodePath`/containers/${id}/stop`,
			undefined,
			stripUndefined({ signal, t }),
		);
	}
}

/**
 * ContainerRestartCommand
 *
 * @summary Restart a container
 */
export class ContainerRestartCommand extends Command<
	ContainerRestartCommandInput,
	undefined,
	ContainerRestartCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ContainerRestartCommandInput) {
		const { id, signal, t } = input;
		super(
			encodePath`/containers/${id}/restart`,
			undefined,
			stripUndefined({ signal, t }),
		);
	}
}

/**
 * Send a POSIX signal to a container, defaulting to killing to the
 * container.
 *
 * @summary Kill a container
 */
export class ContainerKillCommand extends Command<
	ContainerKillCommandInput,
	undefined,
	ContainerKillCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ContainerKillCommandInput) {
		const { id, signal } = input;
		super(
			encodePath`/containers/${id}/kill`,
			undefined,
			stripUndefined({ signal }),
		);
	}
}

/**
 * Change various configuration options of a container without having to
 * recreate it.
 *
 * @summary Update a container
 */
export class ContainerUpdateCommand extends Command<
	ContainerUpdateCommandInput,
	ContainerUpdateCommandOutput
> {
	public override method = "post" as const;

	constructor(input: ContainerUpdateCommandInput) {
		const { id, ...body } = input;
		super(encodePath`/containers/${id}/update`, jsonStringify(body));
	}
}

/**
 * ContainerRenameCommand
 *
 * @summary Rename a container
 */
export class ContainerRenameCommand extends Command<
	ContainerRenameCommandInput,
	undefined,
	ContainerRenameCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ContainerRenameCommandInput) {
		const { id, name } = input;
		super(
			encodePath`/containers/${id}/rename`,
			undefined,
			stripUndefined({ name }),
		);
	}
}

/**
 * Use the freezer cgroup to suspend all processes in a container.
 *
 * Traditionally, when suspending a process the `SIGSTOP` signal is used,
 * which is observable by the process being suspended. With the freezer
 * cgroup the process is unaware, and unable to capture, that it is being
 * suspended, and subsequently resumed.
 *
 * @summary Pause a container
 */
export class ContainerPauseCommand extends Command<
	ContainerPauseCommandInput,
	undefined
> {
	public override method = "post" as const;

	constructor(input: ContainerPauseCommandInput) {
		const { id } = input;
		super(encodePath`/containers/${id}/pause`);
	}
}

/**
 * Resume a container which has been paused.
 *
 * @summary Unpause a container
 */
export class ContainerUnpauseCommand extends Command<
	ContainerUnpauseCommandInput,
	undefined
> {
	public override method = "post" as const;

	constructor(input: ContainerUnpauseCommandInput) {
		const { id } = input;
		super(encodePath`/containers/${id}/unpause`);
	}
}

/**
 * Attach to a container to read its output or send it input. You can attach
 * to the same container multiple times and you can reattach to containers
 * that have been detached.
 *
 * Either the `stream` or `logs` parameter must be `true` for this endpoint
 * to do anything.
 *
 * See the [documentation for the `docker attach`
 * command](https://docs.docker.com/engine/reference/commandline/attach/)
 * for more details.
 *
 * ### Hijacking
 *
 * This endpoint hijacks the HTTP connection to transport `stdin`, `stdout`,
 * and `stderr` on the same socket.
 *
 * This is the response from the daemon for an attach request:
 *
 * ```
 * HTTP/1.1 200 OK
 * Content-Type: application/vnd.docker.raw-stream
 *
 * [STREAM]
 * ```
 *
 * After the headers and two new lines, the TCP connection can now be used
 * for raw, bidirectional communication between the client and server.
 *
 * To hint potential proxies about connection hijacking, the Docker client
 * can also optionally send connection upgrade headers.
 *
 * For example, the client sends this request to upgrade the connection:
 *
 * ```
 * POST /containers/16253994b7c4/attach?stream=1&stdout=1 HTTP/1.1
 * Upgrade: tcp
 * Connection: Upgrade
 * ```
 *
 * The Docker daemon will respond with a `101 UPGRADED` response, and will
 * similarly follow with the raw stream:
 *
 * ```
 * HTTP/1.1 101 UPGRADED
 * Content-Type: application/vnd.docker.raw-stream
 * Connection: Upgrade
 * Upgrade: tcp
 *
 * [STREAM]
 * ```
 *
 * ### Stream format
 *
 * When the TTY setting is disabled in [`POST
 * /containers/create`](#operation/ContainerCreate),
 * the HTTP Content-Type header is set to
 * application/vnd.docker.multiplexed-stream
 * and the stream over the hijacked connected is multiplexed to separate out
 * `stdout` and `stderr`. The stream consists of a series of frames, each
 * containing a header and a payload.
 *
 * The header contains the information which the stream writes (`stdout` or
 * `stderr`). It also contains the size of the associated frame encoded in
 * the last four bytes (`uint32`).
 *
 * It is encoded on the first eight bytes like this:
 *
 * ```go
 * header := [8]byte{STREAM_TYPE, 0, 0, 0, SIZE1, SIZE2, SIZE3, SIZE4}
 * ```
 *
 * `STREAM_TYPE` can be:
 *
 * - 0: `stdin` (is written on `stdout`)
 * - 1: `stdout`
 * - 2: `stderr`
 *
 * `SIZE1, SIZE2, SIZE3, SIZE4` are the four bytes of the `uint32` size
 * encoded as big endian.
 *
 * Following the header is the payload, which is the specified number of
 * bytes of `STREAM_TYPE`.
 *
 * The simplest way to implement this protocol is the following:
 *
 * 1. Read 8 bytes.
 * 2. Choose `stdout` or `stderr` depending on the first byte.
 * 3. Extract the frame size from the last four bytes.
 * 4. Read the extracted size and output it on the correct output.
 * 5. Goto 1.
 *
 * ### Stream format when using a TTY
 *
 * When the TTY setting is enabled in [`POST
 * /containers/create`](#operation/ContainerCreate),
 * the stream is not multiplexed. The data exchanged over the hijacked
 * connection is simply the raw data from the process PTY and client's
 * `stdin`.
 *
 * @summary Attach to a container
 */
export class ContainerAttachCommand extends Command<
	ContainerAttachCommandInput,
	unknown,
	ContainerAttachCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ContainerAttachCommandInput) {
		const { id, detachKeys, logs, stream, stdin, stdout, stderr } = input;
		super(
			encodePath`/containers/${id}/attach`,
			undefined,
			stripUndefined({ detachKeys, logs, stream, stdin, stdout, stderr }),
		);
	}
}

/**
 * ContainerAttachWebsocketCommand
 *
 * @summary Attach to a container via a websocket
 */
export class ContainerAttachWebsocketCommand extends Command<
	ContainerAttachWebsocketCommandInput,
	unknown,
	ContainerAttachWebsocketCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ContainerAttachWebsocketCommandInput) {
		const { id, detachKeys, logs, stream, stdin, stdout, stderr } = input;
		super(
			encodePath`/containers/${id}/attach/ws`,
			undefined,
			stripUndefined({ detachKeys, logs, stream, stdin, stdout, stderr }),
		);
	}
}

/**
 * Block until a container stops, then returns the exit code.
 *
 * @summary Wait for a container
 */
export class ContainerWaitCommand extends Command<
	ContainerWaitCommandInput,
	ContainerWaitCommandOutput,
	ContainerWaitCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ContainerWaitCommandInput) {
		const { id, condition } = input;
		super(
			encodePath`/containers/${id}/wait`,
			undefined,
			stripUndefined({ condition }),
		);
	}
}

/**
 * ContainerDeleteCommand
 *
 * @summary Remove a container
 */
export class ContainerDeleteCommand extends Command<
	ContainerDeleteCommandInput,
	undefined,
	ContainerDeleteCommandQuery
> {
	public override method = "delete" as const;

	constructor(input: ContainerDeleteCommandInput) {
		const { id, v, force, link } = input;
		super(
			encodePath`/containers/${id}`,
			undefined,
			stripUndefined({ v, force, link }),
		);
	}
}

/**
 * Get a tar archive of a resource in the filesystem of container id.
 *
 * @summary Get an archive of a filesystem resource in a container
 */
export class ContainerArchiveCommand extends Command<
	ContainerArchiveCommandInput,
	unknown,
	ContainerArchiveCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ContainerArchiveCommandInput) {
		const { id, path } = input;
		super(
			encodePath`/containers/${id}/archive`,
			undefined,
			stripUndefined({ path }),
		);
	}
}

/**
 * Upload a tar archive to be extracted to a path in the filesystem of
 * container id.
 * `path` parameter is asserted to be a directory. If it exists as a file, 400
 * error
 * will be returned with message "not a directory".
 *
 * @summary Extract an archive of files or folders to a directory in a container
 */
export class PutContainerArchiveCommand extends Command<
	PutContainerArchiveCommandInput,
	unknown,
	PutContainerArchiveCommandQuery
> {
	public override method = "put" as const;

	constructor(input: PutContainerArchiveCommandInput) {
		const { id, path, noOverwriteDirNonDir, copyUIDGID, body } = input;
		super(
			encodePath`/containers/${id}/archive`,
			body,
			stripUndefined({ path, noOverwriteDirNonDir, copyUIDGID }),
		);
	}
}

/**
 * A response header `X-Docker-Container-Path-Stat` is returned, containing
 * a base64 - encoded JSON object with some filesystem header information
 * about the path.
 *
 * @summary Get information about files in a container
 */
export class ContainerArchiveInfoCommand extends Command<
	ContainerArchiveInfoCommandInput,
	unknown,
	ContainerArchiveInfoCommandQuery
> {
	public override method = "head" as const;

	constructor(input: ContainerArchiveInfoCommandInput) {
		const { id, path } = input;
		super(
			encodePath`/containers/${id}/archive`,
			undefined,
			stripUndefined({ path }),
		);
	}
}

/**
 * ContainerPruneCommand
 *
 * @summary Delete stopped containers
 */
export class ContainerPruneCommand extends Command<
	ContainerPruneCommandInput,
	ContainerPruneCommandOutput,
	ContainerPruneCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ContainerPruneCommandInput) {
		const { filters } = input;
		super("/containers/prune", undefined, stripUndefined({ filters }));
	}
}

/**
 * Returns a list of images on the server. Note that it uses a different,
 * smaller representation of an image than inspecting a single image.
 *
 * @summary List Images
 */
export class ImageListCommand extends Command<
	ImageListCommandInput,
	ImageListCommandOutput,
	ImageListCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ImageListCommandInput) {
		const { all, filters, sharedsize, digests } = input;
		super(
			"/images/json",
			undefined,
			stripUndefined({ all, filters, sharedsize, digests }),
		);
	}
}

/**
 * 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](https://docs.docker.com/engine/reference/builder/).
 *
 * 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.
 *
 * @summary Build an image
 */
export class ImageBuildCommand extends Command<
	ImageBuildCommandInput,
	unknown,
	ImageBuildCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ImageBuildCommandInput) {
		const {
			dockerfile,
			t,
			extrahosts,
			remote,
			q,
			nocache,
			cachefrom,
			pull,
			rm,
			forcerm,
			memory,
			memswap,
			cpushares,
			cpusetcpus,
			cpuperiod,
			cpuquota,
			buildargs,
			shmsize,
			squash,
			labels,
			networkmode,
			platform,
			target,
			outputs,
			version,
			body,
		} = input;
		super(
			"/build",
			body,
			stripUndefined({
				dockerfile,
				t,
				extrahosts,
				remote,
				q,
				nocache,
				cachefrom,
				pull,
				rm,
				forcerm,
				memory,
				memswap,
				cpushares,
				cpusetcpus,
				cpuperiod,
				cpuquota,
				buildargs,
				shmsize,
				squash,
				labels,
				networkmode,
				platform,
				target,
				outputs,
				version,
			}),
		);
	}
}

/**
 * BuildPruneCommand
 *
 * @summary Delete builder cache
 */
export class BuildPruneCommand extends Command<
	BuildPruneCommandInput,
	BuildPruneCommandOutput,
	BuildPruneCommandQuery
> {
	public override method = "post" as const;

	constructor(input: BuildPruneCommandInput) {
		const { keepstorage, all, filters } = input;
		super(
			"/build/prune",
			undefined,
			stripUndefined({ keepstorage, all, filters }),
		);
	}
}

/**
 * Create an image by either pulling it from a registry or importing it.
 *
 * @summary Create an image
 */
export class ImageCreateCommand extends Command<
	ImageCreateCommandInput,
	unknown,
	ImageCreateCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ImageCreateCommandInput) {
		const { fromImage, fromSrc, repo, tag, message, changes, platform, body } =
			input;
		super(
			"/images/create",
			body,
			stripUndefined({
				fromImage,
				fromSrc,
				repo,
				tag,
				message,
				changes,
				platform,
			}),
		);
	}
}

/**
 * Return low-level information about an image.
 *
 * @summary Inspect an image
 */
export class ImageInspectCommand extends Command<
	ImageInspectCommandInput,
	ImageInspectCommandOutput
> {
	public override method = "get" as const;

	constructor(input: ImageInspectCommandInput) {
		const { name } = input;
		super(encodePath`/images/${name}/json`);
	}
}

/**
 * Return parent layers of an image.
 *
 * @summary Get the history of an image
 */
export class ImageHistoryCommand extends Command<
	ImageHistoryCommandInput,
	ImageHistoryCommandOutput
> {
	public override method = "get" as const;

	constructor(input: ImageHistoryCommandInput) {
		const { name } = input;
		super(encodePath`/images/${name}/history`);
	}
}

/**
 * Push an image to a registry.
 *
 * If you wish to push an image on to a private registry, that image must
 * already have a tag which references the registry. For example,
 * `registry.example.com/myimage:latest`.
 *
 * The push is cancelled if the HTTP connection is closed.
 *
 * @summary Push an image
 */
export class ImagePushCommand extends Command<
	ImagePushCommandInput,
	unknown,
	ImagePushCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ImagePushCommandInput) {
		const { name, tag } = input;
		super(encodePath`/images/${name}/push`, undefined, stripUndefined({ tag }));
	}
}

/**
 * Tag an image so that it becomes part of a repository.
 *
 * @summary Tag an image
 */
export class ImageTagCommand extends Command<
	ImageTagCommandInput,
	unknown,
	ImageTagCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ImageTagCommandInput) {
		const { name, repo, tag } = input;
		super(
			encodePath`/images/${name}/tag`,
			undefined,
			stripUndefined({ repo, tag }),
		);
	}
}

/**
 * Remove an image, along with any untagged parent images that were
 * referenced by that image.
 *
 * Images can't be removed if they have descendant images, are being
 * used by a running container or are being used by a build.
 *
 * @summary Remove an image
 */
export class ImageDeleteCommand extends Command<
	ImageDeleteCommandInput,
	ImageDeleteCommandOutput,
	ImageDeleteCommandQuery
> {
	public override method = "delete" as const;

	constructor(input: ImageDeleteCommandInput) {
		const { name, force, noprune } = input;
		super(
			encodePath`/images/${name}`,
			undefined,
			stripUndefined({ force, noprune }),
		);
	}
}

/**
 * Search for an image on Docker Hub.
 *
 * @summary Search images
 */
export class ImageSearchCommand extends Command<
	ImageSearchCommandInput,
	ImageSearchCommandOutput,
	ImageSearchCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ImageSearchCommandInput) {
		const { term, limit, filters } = input;
		super(
			"/images/search",
			undefined,
			stripUndefined({ term, limit, filters }),
		);
	}
}

/**
 * ImagePruneCommand
 *
 * @summary Delete unused images
 */
export class ImagePruneCommand extends Command<
	ImagePruneCommandInput,
	ImagePruneCommandOutput,
	ImagePruneCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ImagePruneCommandInput) {
		const { filters } = input;
		super("/images/prune", undefined, stripUndefined({ filters }));
	}
}

/**
 * Validate credentials for a registry and, if available, get an identity
 * token for accessing the registry without password.
 *
 * @summary Check auth configuration
 */
export class SystemAuthCommand extends Command<
	SystemAuthCommandInput,
	SystemAuthCommandOutput,
	undefined
> {
	public override method = "post" as const;

	constructor(input: SystemAuthCommandInput) {
		const body = input;
		super("/auth", jsonStringify(body));
	}
}

/**
 * SystemInfoCommand
 *
 * @summary Get system information
 */
export class SystemInfoCommand extends Command<
	SystemInfoCommandInput,
	SystemInfoCommandOutput
> {
	public override method = "get" as const;
}

/**
 * Returns the version of Docker that is running and various information about
 * the system that Docker is running on.
 *
 * @summary Get version
 */
export class SystemVersionCommand extends Command<
	SystemVersionCommandInput,
	SystemVersionCommandOutput
> {
	public override method = "get" as const;
}

/**
 * This is a dummy endpoint you can use to test if the server is accessible.
 *
 * @summary Ping
 */
export class SystemPingCommand extends Command<
	SystemPingCommandInput,
	unknown
> {
	public override method = "get" as const;
}

/**
 * This is a dummy endpoint you can use to test if the server is accessible.
 *
 * @summary Ping
 */
export class SystemPingHeadCommand extends Command<
	SystemPingHeadCommandInput,
	unknown
> {
	public override method = "head" as const;
}

/**
 * ImageCommitCommand
 *
 * @summary Create a new image from a container
 */
export class ImageCommitCommand extends Command<
	ImageCommitCommandInput,
	ImageCommitCommandOutput,
	ImageCommitCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ImageCommitCommandInput) {
		const { container, repo, tag, comment, author, pause, changes, ...body } =
			input;
		super(
			"/commit",
			jsonStringify(body),
			stripUndefined({ container, repo, tag, comment, author, pause, changes }),
		);
	}
}

/**
 * Stream real-time events from the server.
 *
 * Various objects within Docker report events when something happens to them.
 *
 * Containers report these events: `attach`, `commit`, `copy`, `create`,
 * `destroy`, `detach`, `die`, `exec_create`, `exec_detach`, `exec_start`,
 * `exec_die`, `export`, `health_status`, `kill`, `oom`, `pause`, `rename`,
 * `resize`, `restart`, `start`, `stop`, `top`, `unpause`, `update`, and
 * `prune`
 *
 * Images report these events: `delete`, `import`, `load`, `pull`, `push`,
 * `save`, `tag`, `untag`, and `prune`
 *
 * Volumes report these events: `create`, `mount`, `unmount`, `destroy`, and
 * `prune`
 *
 * Networks report these events: `create`, `connect`, `disconnect`, `destroy`,
 * `update`, `remove`, and `prune`
 *
 * The Docker daemon reports these events: `reload`
 *
 * Services report these events: `create`, `update`, and `remove`
 *
 * Nodes report these events: `create`, `update`, and `remove`
 *
 * Secrets report these events: `create`, `update`, and `remove`
 *
 * Configs report these events: `create`, `update`, and `remove`
 *
 * The Builder reports `prune` events
 *
 * @summary Monitor events
 */
export class SystemEventsCommand extends Command<
	SystemEventsCommandInput,
	SystemEventsCommandOutput,
	SystemEventsCommandQuery
> {
	public override method = "get" as const;

	constructor(input: SystemEventsCommandInput) {
		const { since, until, filters } = input;
		super("/events", undefined, stripUndefined({ since, until, filters }));
	}
}

/**
 * SystemDataUsageCommand
 *
 * @summary Get data usage information
 */
export class SystemDataUsageCommand extends Command<
	SystemDataUsageCommandInput,
	SystemDataUsageCommandOutput,
	SystemDataUsageCommandQuery
> {
	public override method = "get" as const;

	constructor(input: SystemDataUsageCommandInput) {
		const { type } = input;
		super("/system/df", undefined, stripUndefined({ type }));
	}
}

/**
 * Get a tarball containing all images and metadata for a repository.
 *
 * If `name` is a specific name and tag (e.g. `ubuntu:latest`), then only that
 * image (and its parents) are returned. If `name` is an image ID, similarly
 * only that image (and its parents) are returned, but with the exclusion of
 * the `repositories` file in the tarball, as there were no image names
 * referenced.
 *
 * ### Image tarball format
 *
 * An image tarball contains one directory per image layer (named using its
 * long ID), each containing these files:
 *
 * - `VERSION`: currently `1.0` - the file format version
 * - `json`: detailed layer information, similar to `docker inspect layer_id`
 * - `layer.tar`: A tarfile containing the filesystem changes in this layer
 *
 * The `layer.tar` file contains `aufs` style `.wh..wh.aufs` files and
 * directories for storing attribute changes and deletions.
 *
 * If the tarball defines a repository, the tarball should also include a
 * `repositories` file at the root that contains a list of repository and tag
 * names mapped to layer IDs.
 *
 * ```json
 * {
 *
 * "hello-world": {
 *
 * "latest":
 * "565a9d68a73f6706862bfe8409a7f659776d4d60a8d096eb4a3cbce6999cc2a1"
 *
 * }
 * }
 * ```
 *
 * @summary Export an image
 */
export class ImageGetCommand extends Command<ImageGetCommandInput, unknown> {
	public override method = "get" as const;

	constructor(input: ImageGetCommandInput) {
		const { name } = input;
		super(encodePath`/images/${name}/get`);
	}
}

/**
 * Get a tarball containing all images and metadata for several image
 * repositories.
 *
 * For each value of the `names` parameter: if it is a specific name and
 * tag (e.g. `ubuntu:latest`), then only that image (and its parents) are
 * returned; if it is an image ID, similarly only that image (and its parents)
 * are returned and there would be no names referenced in the 'repositories'
 * file for this image ID.
 *
 * For details on the format, see the [export image
 * endpoint](#operation/ImageGet).
 *
 * @summary Export several images
 */
export class ImageGetAllCommand extends Command<
	ImageGetAllCommandInput,
	unknown,
	ImageGetAllCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ImageGetAllCommandInput) {
		const { names } = input;
		super("/images/get", undefined, stripUndefined({ names }));
	}
}

/**
 * Load a set of images and tags into a repository.
 *
 * For details on the format, see the [export image
 * endpoint](#operation/ImageGet).
 *
 * @summary Import images
 */
export class ImageLoadCommand extends Command<
	ImageLoadCommandInput,
	unknown,
	ImageLoadCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ImageLoadCommandInput) {
		const { quiet, body } = input;
		super("/images/load", body, stripUndefined({ quiet }));
	}
}

/**
 * Run a command inside a running container.
 *
 * @summary Create an exec instance
 */
export class ContainerExecCommand extends Command<
	ContainerExecCommandInput,
	ContainerExecCommandOutput
> {
	public override method = "post" as const;

	constructor(input: ContainerExecCommandInput) {
		const { id, ...body } = input;
		super(encodePath`/containers/${id}/exec`, jsonStringify(body));
	}
}

/**
 * Starts a previously set up exec instance. If detach is true, this endpoint
 * returns immediately after starting the command. Otherwise, it sets up an
 * interactive session with the command.
 *
 * @summary Start an exec instance
 */
export class ExecStartCommand extends Command<ExecStartCommandInput, unknown> {
	public override method = "post" as const;

	constructor(input: ExecStartCommandInput) {
		const { id, ...body } = input;
		super(encodePath`/exec/${id}/start`, jsonStringify(body));
	}
}

/**
 * Resize the TTY session used by an exec instance. This endpoint only works
 * if `tty` was specified as part of creating and starting the exec instance.
 *
 * @summary Resize an exec instance
 */
export class ExecResizeCommand extends Command<
	ExecResizeCommandInput,
	unknown,
	ExecResizeCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ExecResizeCommandInput) {
		const { id, h, w } = input;
		super(encodePath`/exec/${id}/resize`, undefined, stripUndefined({ h, w }));
	}
}

/**
 * Return low-level information about an exec instance.
 *
 * @summary Inspect an exec instance
 */
export class ExecInspectCommand extends Command<
	ExecInspectCommandInput,
	ExecInspectCommandOutput
> {
	public override method = "get" as const;

	constructor(input: ExecInspectCommandInput) {
		const { id } = input;
		super(encodePath`/exec/${id}/json`);
	}
}

/**
 * VolumeListCommand
 *
 * @summary List volumes
 */
export class VolumeListCommand extends Command<
	VolumeListCommandInput,
	VolumeListCommandOutput,
	VolumeListCommandQuery
> {
	public override method = "get" as const;

	constructor(input: VolumeListCommandInput) {
		const { filters } = input;
		super("/volumes", undefined, stripUndefined({ filters }));
	}
}

/**
 * VolumeCreateCommand
 *
 * @summary Create a volume
 */
export class VolumeCreateCommand extends Command<
	VolumeCreateCommandInput,
	VolumeCreateCommandOutput
> {
	public override method = "post" as const;

	constructor(input: VolumeCreateCommandInput) {
		const body = input;
		super("/volumes/create", jsonStringify(body));
	}
}

/**
 * VolumeInspectCommand
 *
 * @summary Inspect a volume
 */
export class VolumeInspectCommand extends Command<
	VolumeInspectCommandInput,
	VolumeInspectCommandOutput
> {
	public override method = "get" as const;

	constructor(input: VolumeInspectCommandInput) {
		const { name } = input;
		super(encodePath`/volumes/${name}`);
	}
}

/**
 * VolumeUpdateCommand
 *
 * @summary "Update a volume. Valid only for Swarm cluster volumes"
 */
export class VolumeUpdateCommand extends Command<
	VolumeUpdateCommandInput,
	unknown,
	VolumeUpdateCommandQuery
> {
	public override method = "put" as const;

	constructor(input: VolumeUpdateCommandInput) {
		const { name, version, ...body } = input;
		super(
			encodePath`/volumes/${name}`,
			jsonStringify(body),
			stripUndefined({ version }),
		);
	}
}

/**
 * Instruct the driver to remove the volume.
 *
 * @summary Remove a volume
 */
export class VolumeDeleteCommand extends Command<
	VolumeDeleteCommandInput,
	undefined,
	VolumeDeleteCommandQuery
> {
	public override method = "delete" as const;

	constructor(input: VolumeDeleteCommandInput) {
		const { name, force } = input;
		super(encodePath`/volumes/${name}`, undefined, stripUndefined({ force }));
	}
}

/**
 * VolumePruneCommand
 *
 * @summary Delete unused volumes
 */
export class VolumePruneCommand extends Command<
	VolumePruneCommandInput,
	VolumePruneCommandOutput,
	VolumePruneCommandQuery
> {
	public override method = "post" as const;

	constructor(input: VolumePruneCommandInput) {
		const { filters } = input;
		super("/volumes/prune", undefined, stripUndefined({ filters }));
	}
}

/**
 * Returns a list of networks. For details on the format, see the
 * [network inspect endpoint](#operation/NetworkInspect).
 *
 * Note that it uses a different, smaller representation of a network than
 * inspecting a single network. For example, the list of containers attached
 * to the network is not propagated in API versions 1.28 and up.
 *
 * @summary List networks
 */
export class NetworkListCommand extends Command<
	NetworkListCommandInput,
	NetworkListCommandOutput,
	NetworkListCommandQuery
> {
	public override method = "get" as const;

	constructor(input: NetworkListCommandInput) {
		const { filters } = input;
		super("/networks", undefined, stripUndefined({ filters }));
	}
}

/**
 * NetworkInspectCommand
 *
 * @summary Inspect a network
 */
export class NetworkInspectCommand extends Command<
	NetworkInspectCommandInput,
	NetworkInspectCommandOutput,
	NetworkInspectCommandQuery
> {
	public override method = "get" as const;

	constructor(input: NetworkInspectCommandInput) {
		const { id, verbose, scope } = input;
		super(
			encodePath`/networks/${id}`,
			undefined,
			stripUndefined({ verbose, scope }),
		);
	}
}

/**
 * NetworkDeleteCommand
 *
 * @summary Remove a network
 */
export class NetworkDeleteCommand extends Command<
	NetworkDeleteCommandInput,
	undefined
> {
	public override method = "delete" as const;

	constructor(input: NetworkDeleteCommandInput) {
		const { id } = input;
		super(encodePath`/networks/${id}`);
	}
}

/**
 * NetworkCreateCommand
 *
 * @summary Create a network
 */
export class NetworkCreateCommand extends Command<
	NetworkCreateCommandInput,
	NetworkCreateCommandOutput
> {
	public override method = "post" as const;

	constructor(input: NetworkCreateCommandInput) {
		const body = input;
		super("/networks/create", jsonStringify(body));
	}
}

/**
 * NetworkConnectCommand
 *
 * @summary Connect a container to a network
 */
export class NetworkConnectCommand extends Command<
	NetworkConnectCommandInput,
	unknown
> {
	public override method = "post" as const;

	constructor(input: NetworkConnectCommandInput) {
		const { id, ...body } = input;
		super(encodePath`/networks/${id}/connect`, jsonStringify(body));
	}
}

/**
 * NetworkDisconnectCommand
 *
 * @summary Disconnect a container from a network
 */
export class NetworkDisconnectCommand extends Command<
	NetworkDisconnectCommandInput,
	unknown
> {
	public override method = "post" as const;

	constructor(input: NetworkDisconnectCommandInput) {
		const { id, ...body } = input;
		super(encodePath`/networks/${id}/disconnect`, jsonStringify(body));
	}
}

/**
 * NetworkPruneCommand
 *
 * @summary Delete unused networks
 */
export class NetworkPruneCommand extends Command<
	NetworkPruneCommandInput,
	NetworkPruneCommandOutput,
	NetworkPruneCommandQuery
> {
	public override method = "post" as const;

	constructor(input: NetworkPruneCommandInput) {
		const { filters } = input;
		super("/networks/prune", undefined, stripUndefined({ filters }));
	}
}

/**
 * Returns information about installed plugins.
 *
 * @summary List plugins
 */
export class PluginListCommand extends Command<
	PluginListCommandInput,
	PluginListCommandOutput,
	PluginListCommandQuery
> {
	public override method = "get" as const;

	constructor(input: PluginListCommandInput) {
		const { filters } = input;
		super("/plugins", undefined, stripUndefined({ filters }));
	}
}

/**
 * GetPluginPrivilegesCommand
 *
 * @summary Get plugin privileges
 */
export class GetPluginPrivilegesCommand extends Command<
	GetPluginPrivilegesCommandInput,
	GetPluginPrivilegesCommandOutput,
	GetPluginPrivilegesCommandQuery
> {
	public override method = "get" as const;

	constructor(input: GetPluginPrivilegesCommandInput) {
		const { remote } = input;
		super("/plugins/privileges", undefined, stripUndefined({ remote }));
	}
}

/**
 * Pulls and installs a plugin. After the plugin is installed, it can be
 * enabled using the [`POST /plugins/{name}/enable`
 * endpoint](#operation/PostPluginsEnable).
 *
 * @summary Install a plugin
 */
export class PluginPullCommand extends Command<
	PluginPullCommandInput,
	undefined,
	PluginPullCommandQuery
> {
	public override method = "post" as const;

	constructor(input: PluginPullCommandInput) {
		const { remote, name, ...body } = input;
		super(
			"/plugins/pull",
			jsonStringify(body),
			stripUndefined({ remote, name }),
		);
	}
}

/**
 * PluginInspectCommand
 *
 * @summary Inspect a plugin
 */
export class PluginInspectCommand extends Command<
	PluginInspectCommandInput,
	PluginInspectCommandOutput
> {
	public override method = "get" as const;

	constructor(input: PluginInspectCommandInput) {
		const { name } = input;
		super(encodePath`/plugins/${name}/json`);
	}
}

/**
 * PluginDeleteCommand
 *
 * @summary Remove a plugin
 */
export class PluginDeleteCommand extends Command<
	PluginDeleteCommandInput,
	PluginDeleteCommandOutput,
	PluginDeleteCommandQuery
> {
	public override method = "delete" as const;

	constructor(input: PluginDeleteCommandInput) {
		const { name, force } = input;
		super(encodePath`/plugins/${name}`, undefined, stripUndefined({ force }));
	}
}

/**
 * PluginEnableCommand
 *
 * @summary Enable a plugin
 */
export class PluginEnableCommand extends Command<
	PluginEnableCommandInput,
	unknown,
	PluginEnableCommandQuery
> {
	public override method = "post" as const;

	constructor(input: PluginEnableCommandInput) {
		const { name, timeout } = input;
		super(
			encodePath`/plugins/${name}/enable`,
			undefined,
			stripUndefined({ timeout }),
		);
	}
}

/**
 * PluginDisableCommand
 *
 * @summary Disable a plugin
 */
export class PluginDisableCommand extends Command<
	PluginDisableCommandInput,
	unknown,
	PluginDisableCommandQuery
> {
	public override method = "post" as const;

	constructor(input: PluginDisableCommandInput) {
		const { name, force } = input;
		super(
			encodePath`/plugins/${name}/disable`,
			undefined,
			stripUndefined({ force }),
		);
	}
}

/**
 * PluginUpgradeCommand
 *
 * @summary Upgrade a plugin
 */
export class PluginUpgradeCommand extends Command<
	PluginUpgradeCommandInput,
	undefined,
	PluginUpgradeCommandQuery
> {
	public override method = "post" as const;

	constructor(input: PluginUpgradeCommandInput) {
		const { name, remote, ...body } = input;
		super(
			encodePath`/plugins/${name}/upgrade`,
			jsonStringify(body),
			stripUndefined({ remote }),
		);
	}
}

/**
 * PluginCreateCommand
 *
 * @summary Create a plugin
 */
export class PluginCreateCommand extends Command<
	PluginCreateCommandInput,
	undefined,
	PluginCreateCommandQuery
> {
	public override method = "post" as const;

	constructor(input: PluginCreateCommandInput) {
		const { name, body } = input;
		super("/plugins/create", body, stripUndefined({ name }));
	}
}

/**
 * Push a plugin to the registry.
 *
 * @summary Push a plugin
 */
export class PluginPushCommand extends Command<
	PluginPushCommandInput,
	unknown
> {
	public override method = "post" as const;

	constructor(input: PluginPushCommandInput) {
		const { name } = input;
		super(encodePath`/plugins/${name}/push`);
	}
}

/**
 * PluginSetCommand
 *
 * @summary Configure a plugin
 */
export class PluginSetCommand extends Command<
	PluginSetCommandInput,
	undefined
> {
	public override method = "post" as const;

	constructor(input: PluginSetCommandInput) {
		const { name, ...body } = input;
		super(encodePath`/plugins/${name}/set`, jsonStringify(body));
	}
}

/**
 * NodeListCommand
 *
 * @summary List nodes
 */
export class NodeListCommand extends Command<
	NodeListCommandInput,
	NodeListCommandOutput,
	NodeListCommandQuery
> {
	public override method = "get" as const;

	constructor(input: NodeListCommandInput) {
		const { filters } = input;
		super("/nodes", undefined, stripUndefined({ filters }));
	}
}

/**
 * NodeInspectCommand
 *
 * @summary Inspect a node
 */
export class NodeInspectCommand extends Command<
	NodeInspectCommandInput,
	NodeInspectCommandOutput
> {
	public override method = "get" as const;

	constructor(input: NodeInspectCommandInput) {
		const { id } = input;
		super(encodePath`/nodes/${id}`);
	}
}

/**
 * NodeDeleteCommand
 *
 * @summary Delete a node
 */
export class NodeDeleteCommand extends Command<
	NodeDeleteCommandInput,
	unknown,
	NodeDeleteCommandQuery
> {
	public override method = "delete" as const;

	constructor(input: NodeDeleteCommandInput) {
		const { id, force } = input;
		super(encodePath`/nodes/${id}`, undefined, stripUndefined({ force }));
	}
}

/**
 * NodeUpdateCommand
 *
 * @summary Update a node
 */
export class NodeUpdateCommand extends Command<
	NodeUpdateCommandInput,
	unknown,
	NodeUpdateCommandQuery
> {
	public override method = "post" as const;

	constructor(input: NodeUpdateCommandInput) {
		const { id, version, ...body } = input;
		super(
			encodePath`/nodes/${id}/update`,
			jsonStringify(body),
			stripUndefined({ version }),
		);
	}
}

/**
 * SwarmInspectCommand
 *
 * @summary Inspect swarm
 */
export class SwarmInspectCommand extends Command<
	SwarmInspectCommandInput,
	SwarmInspectCommandOutput
> {
	public override method = "get" as const;
}

/**
 * SwarmInitCommand
 *
 * @summary Initialize a new swarm
 */
export class SwarmInitCommand extends Command<
	SwarmInitCommandInput,
	SwarmInitCommandOutput
> {
	public override method = "post" as const;

	constructor(input: SwarmInitCommandInput) {
		const body = input;
		super("/swarm/init", jsonStringify(body));
	}
}

/**
 * SwarmJoinCommand
 *
 * @summary Join an existing swarm
 */
export class SwarmJoinCommand extends Command<SwarmJoinCommandInput, unknown> {
	public override method = "post" as const;

	constructor(input: SwarmJoinCommandInput) {
		const body = input;
		super("/swarm/join", jsonStringify(body));
	}
}

/**
 * SwarmLeaveCommand
 *
 * @summary Leave a swarm
 */
export class SwarmLeaveCommand extends Command<
	SwarmLeaveCommandInput,
	unknown,
	SwarmLeaveCommandQuery
> {
	public override method = "post" as const;

	constructor(input: SwarmLeaveCommandInput) {
		const { force } = input;
		super("/swarm/leave", undefined, stripUndefined({ force }));
	}
}

/**
 * SwarmUpdateCommand
 *
 * @summary Update a swarm
 */
export class SwarmUpdateCommand extends Command<
	SwarmUpdateCommandInput,
	unknown,
	SwarmUpdateCommandQuery
> {
	public override method = "post" as const;

	constructor(input: SwarmUpdateCommandInput) {
		const {
			version,
			rotateWorkerToken,
			rotateManagerToken,
			rotateManagerUnlockKey,
			...body
		} = input;
		super(
			"/swarm/update",
			jsonStringify(body),
			stripUndefined({
				version,
				rotateWorkerToken,
				rotateManagerToken,
				rotateManagerUnlockKey,
			}),
		);
	}
}

/**
 * SwarmUnlockkeyCommand
 *
 * @summary Get the unlock key
 */
export class SwarmUnlockkeyCommand extends Command<
	SwarmUnlockkeyCommandInput,
	SwarmUnlockkeyCommandOutput
> {
	public override method = "get" as const;
}

/**
 * SwarmUnlockCommand
 *
 * @summary Unlock a locked manager
 */
export class SwarmUnlockCommand extends Command<
	SwarmUnlockCommandInput,
	unknown
> {
	public override method = "post" as const;

	constructor(input: SwarmUnlockCommandInput) {
		const body = input;
		super("/swarm/unlock", jsonStringify(body));
	}
}

/**
 * ServiceListCommand
 *
 * @summary List services
 */
export class ServiceListCommand extends Command<
	ServiceListCommandInput,
	ServiceListCommandOutput,
	ServiceListCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ServiceListCommandInput) {
		const { filters, status } = input;
		super("/services", undefined, stripUndefined({ filters, status }));
	}
}

/**
 * ServiceCreateCommand
 *
 * @summary Create a service
 */
export class ServiceCreateCommand extends Command<
	ServiceCreateCommandInput,
	ServiceCreateCommandOutput
> {
	public override method = "post" as const;

	constructor(input: ServiceCreateCommandInput) {
		const body = input;
		super("/services/create", jsonStringify(body));
	}
}

/**
 * ServiceInspectCommand
 *
 * @summary Inspect a service
 */
export class ServiceInspectCommand extends Command<
	ServiceInspectCommandInput,
	ServiceInspectCommandOutput,
	ServiceInspectCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ServiceInspectCommandInput) {
		const { id, insertDefaults } = input;
		super(
			encodePath`/services/${id}`,
			undefined,
			stripUndefined({ insertDefaults }),
		);
	}
}

/**
 * ServiceDeleteCommand
 *
 * @summary Delete a service
 */
export class ServiceDeleteCommand extends Command<
	ServiceDeleteCommandInput,
	unknown
> {
	public override method = "delete" as const;

	constructor(input: ServiceDeleteCommandInput) {
		const { id } = input;
		super(encodePath`/services/${id}`);
	}
}

/**
 * ServiceUpdateCommand
 *
 * @summary Update a service
 */
export class ServiceUpdateCommand extends Command<
	ServiceUpdateCommandInput,
	ServiceUpdateCommandOutput,
	ServiceUpdateCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ServiceUpdateCommandInput) {
		const { id, version, registryAuthFrom, rollback, ...body } = input;
		super(
			encodePath`/services/${id}/update`,
			jsonStringify(body),
			stripUndefined({ version, registryAuthFrom, rollback }),
		);
	}
}

/**
 * Get `stdout` and `stderr` logs from a service. See also
 * [`/containers/{id}/logs`](#operation/ContainerLogs).
 *
 * **Note**: This endpoint works only for services with the `local`,
 * `json-file` or `journald` logging drivers.
 *
 * @summary Get service logs
 */
export class ServiceLogsCommand extends Command<
	ServiceLogsCommandInput,
	unknown,
	ServiceLogsCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ServiceLogsCommandInput) {
		const { id, details, follow, stdout, stderr, since, timestamps, tail } =
			input;
		super(
			encodePath`/services/${id}/logs`,
			undefined,
			stripUndefined({
				details,
				follow,
				stdout,
				stderr,
				since,
				timestamps,
				tail,
			}),
		);
	}
}

/**
 * TaskListCommand
 *
 * @summary List tasks
 */
export class TaskListCommand extends Command<
	TaskListCommandInput,
	TaskListCommandOutput,
	TaskListCommandQuery
> {
	public override method = "get" as const;

	constructor(input: TaskListCommandInput) {
		const { filters } = input;
		super("/tasks", undefined, stripUndefined({ filters }));
	}
}

/**
 * TaskInspectCommand
 *
 * @summary Inspect a task
 */
export class TaskInspectCommand extends Command<
	TaskInspectCommandInput,
	TaskInspectCommandOutput
> {
	public override method = "get" as const;

	constructor(input: TaskInspectCommandInput) {
		const { id } = input;
		super(encodePath`/tasks/${id}`);
	}
}

/**
 * Get `stdout` and `stderr` logs from a task.
 * See also [`/containers/{id}/logs`](#operation/ContainerLogs).
 *
 * **Note**: This endpoint works only for services with the `local`,
 * `json-file` or `journald` logging drivers.
 *
 * @summary Get task logs
 */
export class TaskLogsCommand extends Command<
	TaskLogsCommandInput,
	unknown,
	TaskLogsCommandQuery
> {
	public override method = "get" as const;

	constructor(input: TaskLogsCommandInput) {
		const { id, details, follow, stdout, stderr, since, timestamps, tail } =
			input;
		super(
			encodePath`/tasks/${id}/logs`,
			undefined,
			stripUndefined({
				details,
				follow,
				stdout,
				stderr,
				since,
				timestamps,
				tail,
			}),
		);
	}
}

/**
 * SecretListCommand
 *
 * @summary List secrets
 */
export class SecretListCommand extends Command<
	SecretListCommandInput,
	SecretListCommandOutput,
	SecretListCommandQuery
> {
	public override method = "get" as const;

	constructor(input: SecretListCommandInput) {
		const { filters } = input;
		super("/secrets", undefined, stripUndefined({ filters }));
	}
}

/**
 * SecretCreateCommand
 *
 * @summary Create a secret
 */
export class SecretCreateCommand extends Command<
	SecretCreateCommandInput,
	SecretCreateCommandOutput
> {
	public override method = "post" as const;

	constructor(input: SecretCreateCommandInput) {
		const body = input;
		super("/secrets/create", jsonStringify(body));
	}
}

/**
 * SecretInspectCommand
 *
 * @summary Inspect a secret
 */
export class SecretInspectCommand extends Command<
	SecretInspectCommandInput,
	SecretInspectCommandOutput
> {
	public override method = "get" as const;

	constructor(input: SecretInspectCommandInput) {
		const { id } = input;
		super(encodePath`/secrets/${id}`);
	}
}

/**
 * SecretDeleteCommand
 *
 * @summary Delete a secret
 */
export class SecretDeleteCommand extends Command<
	SecretDeleteCommandInput,
	undefined
> {
	public override method = "delete" as const;

	constructor(input: SecretDeleteCommandInput) {
		const { id } = input;
		super(encodePath`/secrets/${id}`);
	}
}

/**
 * SecretUpdateCommand
 *
 * @summary Update a Secret
 */
export class SecretUpdateCommand extends Command<
	SecretUpdateCommandInput,
	unknown,
	SecretUpdateCommandQuery
> {
	public override method = "post" as const;

	constructor(input: SecretUpdateCommandInput) {
		const { id, version, ...body } = input;
		super(
			encodePath`/secrets/${id}/update`,
			jsonStringify(body),
			stripUndefined({ version }),
		);
	}
}

/**
 * ConfigListCommand
 *
 * @summary List configs
 */
export class ConfigListCommand extends Command<
	ConfigListCommandInput,
	ConfigListCommandOutput,
	ConfigListCommandQuery
> {
	public override method = "get" as const;

	constructor(input: ConfigListCommandInput) {
		const { filters } = input;
		super("/configs", undefined, stripUndefined({ filters }));
	}
}

/**
 * ConfigCreateCommand
 *
 * @summary Create a config
 */
export class ConfigCreateCommand extends Command<
	ConfigCreateCommandInput,
	ConfigCreateCommandOutput
> {
	public override method = "post" as const;

	constructor(input: ConfigCreateCommandInput) {
		const body = input;
		super("/configs/create", jsonStringify(body));
	}
}

/**
 * ConfigInspectCommand
 *
 * @summary Inspect a config
 */
export class ConfigInspectCommand extends Command<
	ConfigInspectCommandInput,
	ConfigInspectCommandOutput
> {
	public override method = "get" as const;

	constructor(input: ConfigInspectCommandInput) {
		const { id } = input;
		super(encodePath`/configs/${id}`);
	}
}

/**
 * ConfigDeleteCommand
 *
 * @summary Delete a config
 */
export class ConfigDeleteCommand extends Command<
	ConfigDeleteCommandInput,
	undefined
> {
	public override method = "delete" as const;

	constructor(input: ConfigDeleteCommandInput) {
		const { id } = input;
		super(encodePath`/configs/${id}`);
	}
}

/**
 * ConfigUpdateCommand
 *
 * @summary Update a Config
 */
export class ConfigUpdateCommand extends Command<
	ConfigUpdateCommandInput,
	unknown,
	ConfigUpdateCommandQuery
> {
	public override method = "post" as const;

	constructor(input: ConfigUpdateCommandInput) {
		const { id, version, ...body } = input;
		super(
			encodePath`/configs/${id}/update`,
			jsonStringify(body),
			stripUndefined({ version }),
		);
	}
}

/**
 * Return image digest and platform information by contacting the registry.
 *
 * @summary Get image information from the registry
 */
export class DistributionInspectCommand extends Command<
	DistributionInspectCommandInput,
	DistributionInspectCommandOutput
> {
	public override method = "get" as const;

	constructor(input: DistributionInspectCommandInput) {
		const { name } = input;
		super(encodePath`/distribution/${name}/json`);
	}
}

/**
 * Start a new interactive session with a server. Session allows server to
 * call back to the client for advanced capabilities.
 *
 * ### Hijacking
 *
 * This endpoint hijacks the HTTP connection to HTTP2 transport that allows
 * the client to expose gPRC services on that connection.
 *
 * For example, the client sends this request to upgrade the connection:
 *
 * ```
 * POST /session HTTP/1.1
 * Upgrade: h2c
 * Connection: Upgrade
 * ```
 *
 * The Docker daemon responds with a `101 UPGRADED` response follow with
 * the raw stream:
 *
 * ```
 * HTTP/1.1 101 UPGRADED
 * Connection: Upgrade
 * Upgrade: h2c
 * ```
 *
 * @summary Initialize interactive session
 */
export class SessionCommand extends Command<SessionCommandInput> {
	public override method = "post" as const;
}