the-moby-effect 1.48.4 → 1.51.0

package/src/internal/endpoints/containers.ts

@@ -1,75 +1,396 @@
-import type * as HttpBody from "@effect/platform/HttpBody";
-import type * as HttpClientError from "@effect/platform/HttpClientError";
-import type * as Layer from "effect/Layer";
-import type * as ParseResult from "effect/ParseResult";
-
-import * as PlatformError from "@effect/platform/Error";
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import * as Socket from "@effect/platform/Socket";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Option from "effect/Option";
-import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
-import * as Stream from "effect/Stream";
-import * as Tuple from "effect/Tuple";
-import * as MobyDemux from "../../MobyDemux.js";
-
 import {
-    ContainerChange,
+    HttpApi,
+    HttpApiClient,
+    HttpApiEndpoint,
+    HttpApiGroup,
+    HttpApiSchema,
+    HttpClient,
+    HttpClientResponse,
+    type Socket,
+} from "@effect/platform";
+import { Effect, Schema, Stream, Tuple, type Layer } from "effect";
+import { I64 } from "effect-schemas/Number";
+
+import { MobyConnectionOptions } from "../../MobyConnection.js";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
+import {
+    ArchiveChange,
     ContainerConfig,
     ContainerCreateRequest,
-    ContainerCreateResponse,
+    ContainerHealth,
+    ContainerHostConfig,
     ContainerInspectResponse,
-    ContainerListResponseItem,
-    ContainerPruneResponse,
+    ContainerState,
     ContainerStatsResponse,
+    ContainerSummary,
     ContainerTopResponse,
-    ContainerUpdateResponse,
     ContainerWaitResponse,
 } from "../generated/index.js";
-import { websocketRequest } from "../platforms/agnostic.js";
-import { maybeAddFilters, maybeAddQueryParameter } from "./common.js";
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const ContainersErrorTypeId: unique symbol = Symbol.for(
-    "@the-moby-effect/endpoints/ContainersError"
-) as ContainersErrorTypeId;
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export type ContainersErrorTypeId = typeof ContainersErrorTypeId;
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const isContainersError = (u: unknown): u is ContainersError => Predicate.hasProperty(u, ContainersErrorTypeId);
+import { ContainerIdentifier } from "../schemas/id.js";
+import { DockerError } from "./circular.ts";
+import {
+    BadRequest,
+    Conflict,
+    Forbidden,
+    HttpApiSocket,
+    HttpApiStreamingRequest,
+    HttpApiStreamingResponse,
+    HttpApiWebsocket,
+    InternalServerError,
+    NotAcceptable,
+    NotFound,
+} from "./httpApiHacks.js";
+
+/** @since 1.0.0 */
+export class ListFilters extends Schema.parseJson(
+    Schema.Struct({
+        ancestor: Schema.optional(Schema.Array(Schema.String)),
+        before: Schema.optional(Schema.Array(Schema.String)),
+        expose: Schema.optional(Schema.Array(Schema.String)),
+        exited: Schema.optional(Schema.Array(Schema.NumberFromString)),
+        health: Schema.optional(Schema.Array(ContainerHealth.fields["Status"])),
+        identifier: Schema.optional(Schema.Array(ContainerIdentifier)),
+        // isolation: Schema.optional(Schema.Array(ContainerHostConfig.fields["Isolation"])),
+        "is-task": Schema.optional(Schema.BooleanFromString),
+        label: Schema.optional(Schema.Array(Schema.String)),
+        name: Schema.optional(Schema.Array(Schema.String)),
+        network: Schema.optional(Schema.Array(Schema.String)),
+        publish: Schema.optional(Schema.Array(Schema.String)),
+        since: Schema.optional(Schema.Array(Schema.String)),
+        status: Schema.optional(Schema.Array(ContainerState.fields["Status"])),
+        volume: Schema.optional(Schema.String),
+    })
+) {}
+
+/** @since 1.0.0 */
+export class PruneFilters extends Schema.parseJson(
+    Schema.Struct({
+        until: Schema.optional(Schema.String),
+        label: Schema.optional(Schema.Array(Schema.String)),
+    })
+) {}
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerList */
+const listContainersEndpoint = HttpApiEndpoint.get("list", "/json")
+    .setUrlParams(
+        Schema.Struct({
+            all: Schema.optional(Schema.BooleanFromString),
+            limit: Schema.optional(Schema.NumberFromString),
+            size: Schema.optional(Schema.BooleanFromString),
+            filters: Schema.optional(ListFilters),
+        })
+    )
+    .addSuccess(Schema.Array(ContainerSummary), { status: 200 }) // 200 OK
+    .addError(BadRequest); // 400 Bad parameter
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerCreate */
+const createContainerEndpoint = HttpApiEndpoint.post("create", "/create")
+    .setUrlParams(
+        Schema.Struct({
+            platform: Schema.optional(Schema.String),
+            name: Schema.String.pipe(Schema.pattern(/^[a-zA-Z0-9][a-zA-Z0-9_.-]+/)).pipe(Schema.optional),
+        })
+    )
+    .setPayload(ContainerCreateRequest)
+    .addSuccess(
+        Schema.Struct({
+            Id: ContainerIdentifier,
+            Warnings: Schema.NullOr(Schema.Array(Schema.String)),
+        }),
+        { status: 201 }
+    ) // 201 Created
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(Forbidden) // 403 Forbidden
+    .addError(NotFound) // 404 Not Found
+    .addError(NotAcceptable) // 406 Not Acceptable
+    .addError(Conflict); // 409 Name conflicts
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerInspect */
+const inspectContainerEndpoint = HttpApiEndpoint.get("inspect", "/:identifier/json")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(Schema.Struct({ size: Schema.optional(Schema.BooleanFromString) }))
+    .addSuccess(ContainerInspectResponse) // 200 OK
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerTop */
+const topContainerEndpoint = HttpApiEndpoint.get("top", "/:identifier/top")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(Schema.Struct({ ps_args: Schema.optional(Schema.String) }))
+    .addSuccess(ContainerTopResponse) // 200 OK
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerLogs */
+const logsContainerEndpoint = HttpApiEndpoint.get("logs", "/:identifier/logs")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            follow: Schema.optional(Schema.BooleanFromString),
+            stdout: Schema.optional(Schema.BooleanFromString),
+            stderr: Schema.optional(Schema.BooleanFromString),
+            since: Schema.optional(Schema.NumberFromString),
+            until: Schema.optional(Schema.NumberFromString),
+            timestamps: Schema.optional(Schema.BooleanFromString),
+            tail: Schema.optional(Schema.String),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerChanges */
+const changesContainerEndpoint = HttpApiEndpoint.get("changes", "/:identifier/changes")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .addSuccess(Schema.NullOr(Schema.Array(ArchiveChange)), { status: 200 }) // 200 OK
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerExport */
+const exportContainerEndpoint = HttpApiEndpoint.get("export", "/:identifier/export")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerStats */
+const statsContainerEndpoint = HttpApiEndpoint.get("stats", "/:identifier/stats")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            stream: Schema.optional(Schema.BooleanFromString),
+            "one-shot": Schema.optional(Schema.BooleanFromString),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerResize */
+const resizeContainerEndpoint = HttpApiEndpoint.post("resize", "/:identifier/resize")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            h: Schema.optional(Schema.NumberFromString),
+            w: Schema.optional(Schema.NumberFromString),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerStart */
+const startContainerEndpoint = HttpApiEndpoint.post("start", "/:identifier/start")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            detachKeys: Schema.optional(Schema.String),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
+    .addSuccess(HttpApiSchema.Empty(304)) // 304 Container already started
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerStop */
+const stopContainerEndpoint = HttpApiEndpoint.post("stop", "/:identifier/stop")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            signal: Schema.optional(Schema.String),
+            t: Schema.optional(Schema.NumberFromString),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
+    .addSuccess(HttpApiSchema.Empty(304)) // 304 Container already stopped
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerRestart */
+const restartContainerEndpoint = HttpApiEndpoint.post("restart", "/:identifier/restart")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            signal: Schema.optional(Schema.String),
+            t: Schema.optional(Schema.NumberFromString),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerKill */
+const killContainerEndpoint = HttpApiEndpoint.post("kill", "/:identifier/kill")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            signal: Schema.optional(Schema.String),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
+    .addError(NotFound) // 404 Not Found
+    .addError(Conflict); // 409 Container is not running
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerUpdate */
+const updateContainerEndpoint = HttpApiEndpoint.post("update", "/:identifier/update")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setPayload(ContainerConfig)
+    .addSuccess(Schema.Struct({ Warnings: Schema.NullOr(Schema.Array(Schema.String)) }), { status: 200 }) // 200 OK
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerRename */
+const renameContainerEndpoint = HttpApiEndpoint.post("rename", "/:identifier/rename")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(Schema.Struct({ name: Schema.String }))
+    .addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
+    .addError(NotFound) // 404 Not Found
+    .addError(Conflict); // 409 Name already in use
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerPause */
+const pauseContainerEndpoint = HttpApiEndpoint.post("pause", "/:identifier/pause")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerUnpause */
+const unpauseContainerEndpoint = HttpApiEndpoint.post("unpause", "/:identifier/unpause")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerAttach */
+const attachContainerEndpoint = HttpApiEndpoint.post("attach", "/:identifier/attach")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            detachKeys: Schema.optional(Schema.String),
+            logs: Schema.optional(Schema.BooleanFromString),
+            stream: Schema.optional(Schema.BooleanFromString),
+            stdin: Schema.optional(Schema.BooleanFromString),
+            stdout: Schema.optional(Schema.BooleanFromString),
+            stderr: Schema.optional(Schema.BooleanFromString),
+        })
+    )
+    .setHeaders(
+        Schema.Struct({
+            Upgrade: Schema.Literal("tcp"),
+            Connection: Schema.Literal("Upgrade"),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(101)) // 101 Switching Protocols
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerAttachWebsocket */
+const attachWebsocketContainerEndpoint = HttpApiEndpoint.get("attachWebsocket", "/:identifier/attach/ws")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            detachKeys: Schema.optional(Schema.String),
+            logs: Schema.optional(Schema.BooleanFromString),
+            stream: Schema.optional(Schema.BooleanFromString),
+            stdin: Schema.optional(Schema.BooleanFromString),
+            stdout: Schema.optional(Schema.BooleanFromString),
+            stderr: Schema.optional(Schema.BooleanFromString),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(101)) // 101 Switching Protocols
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerWait */
+const waitContainerEndpoint = HttpApiEndpoint.post("wait", "/:identifier/wait")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(Schema.Struct({ condition: Schema.optional(Schema.String) }))
+    .addSuccess(ContainerWaitResponse, { status: 200 }) // 200 OK
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerDelete */
+const deleteContainerEndpoint = HttpApiEndpoint.del("delete", "/:identifier")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            v: Schema.optional(Schema.BooleanFromString),
+            force: Schema.optional(Schema.BooleanFromString),
+            link: Schema.optional(Schema.BooleanFromString),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(NotFound) // 404 Not Found
+    .addError(Conflict); // 409 Conflict
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerArchive */
+const archiveContainerEndpoint = HttpApiEndpoint.get("archive", "/:identifier/archive")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(Schema.Struct({ path: Schema.String }))
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerArchiveInfo */
+const archiveInfoContainerEndpoint = HttpApiEndpoint.head("archiveInfo", "/:identifier/archive")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(Schema.Struct({ path: Schema.String }))
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/PutContainerArchive */
+const putArchiveContainerEndpoint = HttpApiEndpoint.put("putArchive", "/:identifier/archive")
+    .setPath(Schema.Struct({ identifier: ContainerIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            path: Schema.String,
+            noOverwriteDirNonDir: Schema.optional(Schema.String),
+            copyUIDGidentifier: Schema.optional(Schema.String),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(Forbidden) // 403 Forbidden
+    .addError(NotFound); // 404 Not Found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerPrune */
+const pruneContainersEndpoint = HttpApiEndpoint.post("prune", "/prune")
+    .setUrlParams(Schema.Struct({ filters: Schema.optional(PruneFilters) }))
+    .addSuccess(
+        Schema.Struct({
+            ContainersDeleted: Schema.NullOr(Schema.Array(ContainerIdentifier)),
+            SpaceReclaimed: I64,
+        }),
+        { status: 200 }
+    ); // 200 OK
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container */
+const ContainersGroup = HttpApiGroup.make("containers")
+    .add(listContainersEndpoint)
+    .add(createContainerEndpoint)
+    .add(inspectContainerEndpoint)
+    .add(topContainerEndpoint)
+    .add(logsContainerEndpoint)
+    .add(changesContainerEndpoint)
+    .add(exportContainerEndpoint)
+    .add(statsContainerEndpoint)
+    .add(resizeContainerEndpoint)
+    .add(startContainerEndpoint)
+    .add(stopContainerEndpoint)
+    .add(restartContainerEndpoint)
+    .add(killContainerEndpoint)
+    .add(updateContainerEndpoint)
+    .add(renameContainerEndpoint)
+    .add(pauseContainerEndpoint)
+    .add(unpauseContainerEndpoint)
+    .add(attachContainerEndpoint)
+    .add(attachWebsocketContainerEndpoint)
+    .add(waitContainerEndpoint)
+    .add(deleteContainerEndpoint)
+    .add(archiveContainerEndpoint)
+    .add(archiveInfoContainerEndpoint)
+    .add(putArchiveContainerEndpoint)
+    .add(pruneContainersEndpoint)
+    .addError(InternalServerError)
+    .prefix("/containers");
 
 /**
  * @since 1.0.0
- * @category Errors
+ * @category HttpApi
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Container
  */
-export class ContainersError extends PlatformError.TypeIdError(ContainersErrorTypeId, "ContainersError")<{
-    method: string;
-    cause:
-        | ParseResult.ParseError
-        | HttpClientError.HttpClientError
-        | HttpBody.HttpBodyError
-        | Socket.SocketError
-        | unknown;
-}> {
-    get message() {
-        return `${this.method}`;
-    }
-}
+export const ContainersApi = HttpApi.make("ContainersApi").add(ContainersGroup);
 
 /**
  * @since 1.0.0
@@ -78,504 +399,184 @@ export class ContainersError extends PlatformError.TypeIdError(ContainersErrorTy
  */
 export class Containers extends Effect.Service<Containers>()("@the-moby-effect/endpoints/Containers", {
     accessors: false,
-    dependencies: [],
+    dependencies: [
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        ),
+    ],
 
     effect: Effect.gen(function* () {
-        const contextClient = yield* HttpClient.HttpClient;
-        const client = contextClient.pipe(HttpClient.filterStatusOk);
-        const maybeUpgradedClient = contextClient.pipe(
-            HttpClient.filterStatus((status) => (status >= 200 && status < 300) || status === 101)
-        );
-
-        const websocketConstructor = yield* Socket.WebSocketConstructor;
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerList */
-        const list_ = (
-            options?:
-                | {
-                      readonly all?: boolean | undefined;
-                      readonly limit?: number | undefined;
-                      readonly size?: boolean | undefined;
-                      readonly filters?:
-                          | {
-                                ancestor?: string | undefined;
-                                before?: string | undefined;
-                                expose?: `${number}/${string}` | `${number}-${number}/${string}` | undefined;
-                                exited?: number | undefined;
-                                health?: "starting" | "healthy" | "unhealthy" | "none" | undefined;
-                                id?: string | undefined;
-                                isolation?: "default" | "process" | "hyperv" | undefined;
-                                "is-task"?: true | false | undefined;
-                                label?: Record<string, string> | undefined;
-                                name?: string | undefined;
-                                network?: string | undefined;
-                                publish?: `${number}/${string}` | `${number}-${number}/${string}` | undefined;
-                                since?: string | undefined;
-                                status?:
-                                    | "created"
-                                    | "restarting"
-                                    | "running"
-                                    | "removing"
-                                    | "paused"
-                                    | "exited"
-                                    | "dead"
-                                    | undefined;
-                                volume?: string | undefined;
-                            }
-                          | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<ReadonlyArray<ContainerListResponseItem>, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.get("/containers/json"),
-                maybeAddQueryParameter("all", Option.fromNullable(options?.all)),
-                maybeAddQueryParameter("limit", Option.fromNullable(options?.limit)),
-                maybeAddQueryParameter("size", Option.fromNullable(options?.size)),
-                maybeAddFilters(options?.filters),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(ContainerListResponseItem))),
-                Effect.mapError((cause) => new ContainersError({ method: "list", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerCreate */
-        const create_ = (options: {
-            readonly name?: string | undefined;
-            readonly platform?: string | undefined;
-            readonly spec: typeof ContainerCreateRequest.Encoded;
-        }): Effect.Effect<ContainerCreateResponse, ContainersError, never> =>
-            Function.pipe(
-                Schema.decode(ContainerCreateRequest)(options.spec),
-                Effect.map((body) => Tuple.make(HttpClientRequest.post("/containers/create"), body)),
-                Effect.map(Tuple.mapFirst(maybeAddQueryParameter("name", Option.fromNullable(options.name)))),
-                Effect.map(Tuple.mapFirst(maybeAddQueryParameter("platform", Option.fromNullable(options.platform)))),
-                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(ContainerCreateRequest))),
-                Effect.flatMap(client.execute),
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(ContainerCreateResponse)),
-                Effect.mapError((cause) => new ContainersError({ method: "create", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerInspect */
-        const inspect_ = (
-            id: string,
-            options?:
-                | {
-                      readonly size?: boolean | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<ContainerInspectResponse, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/containers/${encodeURIComponent(id)}/json`),
-                maybeAddQueryParameter("size", Option.fromNullable(options?.size)),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(ContainerInspectResponse)),
-                Effect.mapError((cause) => new ContainersError({ method: "inspect", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerTop */
-        const top_ = (
-            id: string,
-            options?:
-                | {
-                      readonly ps_args?: string | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<ContainerTopResponse, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/containers/${encodeURIComponent(id)}/top`),
-                maybeAddQueryParameter("ps_args", Option.fromNullable(options?.ps_args)),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(ContainerTopResponse)),
-                Effect.mapError((cause) => new ContainersError({ method: "top", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerLogs */
-        const logs_ = (
-            id: string,
-            options?:
-                | {
-                      readonly follow?: boolean | undefined;
-                      readonly stdout?: boolean | undefined;
-                      readonly stderr?: boolean | undefined;
-                      readonly since?: number | undefined;
-                      readonly until?: number | undefined;
-                      readonly timestamps?: boolean | undefined;
-                      readonly tail?: string | undefined;
-                  }
-                | undefined
-        ): Stream.Stream<string, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/containers/${encodeURIComponent(id)}/logs`),
-                maybeAddQueryParameter("follow", Option.fromNullable(options?.follow)),
-                maybeAddQueryParameter("stdout", Option.fromNullable(options?.stdout)),
-                maybeAddQueryParameter("stderr", Option.fromNullable(options?.stderr)),
-                maybeAddQueryParameter("since", Option.fromNullable(options?.since)),
-                maybeAddQueryParameter("until", Option.fromNullable(options?.until)),
-                maybeAddQueryParameter("timestamps", Option.fromNullable(options?.timestamps)),
-                maybeAddQueryParameter("tail", Option.fromNullable(options?.tail)),
-                client.execute,
-                HttpClientResponse.stream,
-                Stream.decodeText(),
-                Stream.mapError((cause) => new ContainersError({ method: "logs", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerChanges */
-        const changes_ = (id: string): Effect.Effect<ReadonlyArray<ContainerChange> | null, ContainersError> =>
-            Function.pipe(
-                HttpClientRequest.get(`/containers/${encodeURIComponent(id)}/changes`),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.NullOr(Schema.Array(ContainerChange)))),
-                Effect.mapError((cause) => new ContainersError({ method: "changes", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerExport */
-        const export_ = (id: string): Stream.Stream<Uint8Array, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/containers/${encodeURIComponent(id)}/export`),
-                client.execute,
-                HttpClientResponse.stream,
-                Stream.mapError((cause) => new ContainersError({ method: "export", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerStats */
-        const stats_ = (
-            id: string,
-            options?:
-                | {
-                      readonly stream?: boolean | undefined;
-                      readonly "one-shot"?: boolean | undefined;
-                  }
-                | undefined
-        ): Stream.Stream<ContainerStatsResponse, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/containers/${encodeURIComponent(id)}/stats`),
-                maybeAddQueryParameter("stream", Option.fromNullable(options?.stream)),
-                maybeAddQueryParameter("one-shot", Option.fromNullable(options?.["one-shot"])),
-                client.execute,
-                HttpClientResponse.stream,
-                Stream.decodeText(),
-                Stream.mapEffect(Schema.decode(Schema.parseJson(ContainerStatsResponse))),
-                Stream.mapError((cause) => new ContainersError({ method: "stats", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerResize */
-        const resize_ = (
-            id: string,
-            options?:
-                | {
-                      readonly h?: number | undefined;
-                      readonly w?: number | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/resize`),
-                maybeAddQueryParameter("h", Option.fromNullable(options?.h)),
-                maybeAddQueryParameter("w", Option.fromNullable(options?.w)),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "resize", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerStart */
-        const start_ = (
-            id: string,
-            options?:
-                | {
-                      readonly detachKeys?: string | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/start`),
-                maybeAddQueryParameter("detachKeys", Option.fromNullable(options?.detachKeys)),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "start", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerStop */
-        const stop_ = (
-            id: string,
-            options?:
-                | {
-                      readonly signal?: string | undefined;
-                      readonly t?: number | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/stop`),
-                maybeAddQueryParameter("signal", Option.fromNullable(options?.signal)),
-                maybeAddQueryParameter("t", Option.fromNullable(options?.t)),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "stop", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerRestart */
-        const restart_ = (
-            id: string,
-            options?:
-                | {
-                      readonly signal?: string | undefined;
-                      readonly t?: number | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/restart`),
-                maybeAddQueryParameter("signal", Option.fromNullable(options?.signal)),
-                maybeAddQueryParameter("t", Option.fromNullable(options?.t)),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "restart", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerKill */
-        const kill_ = (
-            id: string,
-            options?:
-                | {
-                      readonly signal?: string | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/kill`),
-                maybeAddQueryParameter("signal", Option.fromNullable(options?.signal)),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "kill", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerUpdate */
-        const update_ = (
-            id: string,
-            options: {
-                readonly spec: ContainerConfig;
+        type Options<Name extends (typeof ContainersGroup.endpoints)[number]["name"]> =
+            HttpApiEndpoint.HttpApiEndpoint.UrlParams<
+                HttpApiEndpoint.HttpApiEndpoint.WithName<(typeof ContainersGroup.endpoints)[number], Name>
+            >;
+
+        const httpClient = yield* HttpClient.HttpClient;
+        const ContainersError = DockerError.WrapForModule("containers");
+        const context = yield* Effect.context<Socket.WebSocketConstructor>();
+        const client = yield* HttpApiClient.group(ContainersApi, {
+            httpClient,
+            group: "containers",
+        });
+
+        const list_ = (filters?: Schema.Schema.Type<ListFilters> | undefined) =>
+            Effect.mapError(client.list({ urlParams: { filters } }), ContainersError("list"));
+        const create_ = (
+            options: Omit<ConstructorParameters<typeof ContainerCreateRequest>[0], "HostConfig"> & {
+                readonly Name?: string | undefined;
+                readonly Platform?: string | undefined;
+                readonly HostConfig?: ConstructorParameters<typeof ContainerHostConfig>[0] | undefined;
             }
-        ): Effect.Effect<ContainerUpdateResponse, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/update`),
-                HttpClientRequest.schemaBodyJson(ContainerConfig)(options.spec),
-                Effect.flatMap(client.execute),
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(ContainerUpdateResponse)),
-                Effect.mapError((cause) => new ContainersError({ method: "update", cause }))
+        ) =>
+            Effect.mapError(
+                client.create({
+                    urlParams: { name: options.Name, platform: options.Platform },
+                    payload: ContainerCreateRequest.make({
+                        ...options,
+                        HostConfig: options.HostConfig ? ContainerHostConfig.make(options.HostConfig) : undefined,
+                    }),
+                }),
+                ContainersError("create")
             );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerRename */
-        const rename_ = (
-            id: string,
-            options: {
-                readonly name: string;
-            }
-        ): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/rename`),
-                maybeAddQueryParameter("name", Option.fromNullable(options.name)),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "rename", cause }))
+        const inspect_ = (identifier: ContainerIdentifier, options?: Options<"inspect">) =>
+            Effect.mapError(
+                client.inspect({ path: { identifier }, urlParams: { ...options } }),
+                ContainersError("inspect")
             );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerPause */
-        const pause_ = (id: string): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/pause`),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "pause", cause }))
+        const top_ = (identifier: ContainerIdentifier, options?: Options<"top">) =>
+            Effect.mapError(client.top({ path: { identifier }, urlParams: { ...options } }), ContainersError("top"));
+        const logs_ = (identifier: ContainerIdentifier, options?: Options<"logs">) =>
+            HttpApiStreamingResponse(
+                ContainersApi,
+                "containers",
+                "logs",
+                httpClient
+            )({ path: { identifier }, urlParams: { ...options } })
+                .pipe(Stream.decodeText())
+                .pipe(Stream.splitLines)
+                .pipe(Stream.mapError(ContainersError("logs")));
+        const changes_ = (identifier: ContainerIdentifier) =>
+            Effect.mapError(client.changes({ path: { identifier } }), ContainersError("changes"));
+        const export_ = (identifier: ContainerIdentifier) =>
+            Stream.mapError(
+                HttpApiStreamingResponse(ContainersApi, "containers", "export", httpClient)({ path: { identifier } }),
+                ContainersError("export")
             );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerUnpause */
-        const unpause_ = (id: string): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/unpause`),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "unpause", cause }))
+        const stats_ = (identifier: ContainerIdentifier, options?: Options<"stats">) =>
+            HttpApiStreamingResponse(
+                ContainersApi,
+                "containers",
+                "stats",
+                httpClient
+            )({ path: { identifier }, urlParams: { ...options } })
+                .pipe(Stream.decodeText())
+                .pipe(Stream.splitLines)
+                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(ContainerStatsResponse))))
+                .pipe(Stream.mapError(ContainersError("stats")));
+        const resize_ = (identifier: ContainerIdentifier, options?: Options<"resize">) =>
+            Effect.mapError(
+                client.resize({ path: { identifier }, urlParams: { ...options } }),
+                ContainersError("resize")
             );
-
-        /**
-         * Attach to a container
-         *
-         * @param options.id - ID or name of the container
-         * @param detachKeys - Override the key sequence for detaching a
-         *   container.Format is a single character `[a-Z]` or `ctrl-<value>`
-         *   where `<value>` is one of: `a-z`, `@`, `^`, `[`, `,` or `_`.
-         * @param logs - Replay previous logs from the container.
-         *
-         *   This is useful for attaching to a container that has started and you
-         *   want to output everything since the container started.
-         *
-         *   If `stream` is also enabled, once all the previous output has been
-         *   returned, it will seamlessly transition into streaming current
-         *   output.
-         * @param stream - Stream attached streams from the time the request was
-         *   made onwards.
-         * @param stdin - Attach to `stdin`
-         * @param stdout - Attach to `stdout`
-         * @param stderr - Attach to `stderr`
-         * @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerAttach
-         */
-        const attach_ = (
-            id: string,
-            options?:
-                | {
-                      readonly detachKeys?: string | undefined;
-                      readonly logs?: boolean | undefined;
-                      readonly stream?: boolean | undefined;
-                      readonly stdin?: boolean | undefined;
-                      readonly stdout?: boolean | undefined;
-                      readonly stderr?: boolean | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<MobyDemux.RawSocket | MobyDemux.MultiplexedSocket, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/attach`),
-                HttpClientRequest.setHeader("Upgrade", "tcp"),
-                HttpClientRequest.setHeader("Connection", "Upgrade"),
-                maybeAddQueryParameter("detachKeys", Option.fromNullable(options?.detachKeys)),
-                maybeAddQueryParameter("logs", Option.fromNullable(options?.logs)),
-                maybeAddQueryParameter("stream", Option.fromNullable(options?.stream)),
-                maybeAddQueryParameter("stdin", Option.fromNullable(options?.stdin)),
-                maybeAddQueryParameter("stdout", Option.fromNullable(options?.stdout)),
-                maybeAddQueryParameter("stderr", Option.fromNullable(options?.stderr)),
-                maybeUpgradedClient.execute,
-                Effect.flatMap(MobyDemux.responseToStreamingSocketOrFailUnsafe),
-                Effect.mapError((cause) => new ContainersError({ method: "attach", cause }))
+        const start_ = (identifier: ContainerIdentifier, options?: Options<"start">) =>
+            Effect.mapError(
+                client.start({ path: { identifier }, urlParams: { ...options } }),
+                ContainersError("start")
             );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerAttachWebsocket */
-        const attachWebsocket_ = (
-            id: string,
-            options?:
-                | {
-                      readonly detachKeys?: string | undefined;
-                      readonly logs?: boolean | undefined;
-                      readonly stream?: boolean | undefined;
-                      readonly stdin?: boolean | undefined;
-                      readonly stdout?: boolean | undefined;
-                      readonly stderr?: boolean | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<MobyDemux.RawSocket, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/containers/${encodeURIComponent(id)}/attach/ws`),
-                maybeAddQueryParameter("detachKeys", Option.fromNullable(options?.detachKeys)),
-                maybeAddQueryParameter("logs", Option.fromNullable(options?.logs)),
-                maybeAddQueryParameter("stream", Option.fromNullable(options?.stream)),
-                maybeAddQueryParameter("stdin", Option.fromNullable(options?.stdin)),
-                maybeAddQueryParameter("stdout", Option.fromNullable(options?.stdout)),
-                maybeAddQueryParameter("stderr", Option.fromNullable(options?.stderr)),
-                websocketRequest,
-                Effect.map(MobyDemux.makeRawSocket),
-                Effect.provideService(HttpClient.HttpClient, contextClient),
-                Effect.provideService(Socket.WebSocketConstructor, websocketConstructor),
-                Effect.mapError((cause) => new ContainersError({ method: "attachWebsocket", cause }))
+        const stop_ = (identifier: ContainerIdentifier, options?: Options<"stop">) =>
+            Effect.mapError(client.stop({ path: { identifier }, urlParams: { ...options } }), ContainersError("stop"));
+        const restart_ = (identifier: ContainerIdentifier, options?: Options<"restart">) =>
+            Effect.mapError(
+                client.restart({ path: { identifier }, urlParams: { ...options } }),
+                ContainersError("restart")
             );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerWait */
-        const wait_ = (
-            id: string,
-            options?: { readonly condition?: string | undefined } | undefined
-        ): Effect.Effect<ContainerWaitResponse, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/wait`),
-                maybeAddQueryParameter("condition", Option.fromNullable(options?.condition)),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(ContainerWaitResponse)),
-                Effect.mapError((cause) => new ContainersError({ method: "wait", cause }))
+        const kill_ = (identifier: ContainerIdentifier, options?: Options<"kill">) =>
+            Effect.mapError(client.kill({ path: { identifier }, urlParams: { ...options } }), ContainersError("kill"));
+        const update_ = (identifier: ContainerIdentifier, config: ContainerConfig) =>
+            Effect.mapError(client.update({ path: { identifier }, payload: config }), ContainersError("update"));
+        const rename_ = (identifier: ContainerIdentifier, name: string) =>
+            Effect.mapError(client.rename({ path: { identifier }, urlParams: { name } }), ContainersError("rename"));
+        const pause_ = (identifier: ContainerIdentifier) =>
+            Effect.mapError(client.pause({ path: { identifier } }), ContainersError("pause"));
+        const unpause_ = (identifier: ContainerIdentifier) =>
+            Effect.mapError(client.unpause({ path: { identifier } }), ContainersError("unpause"));
+        const attach_ = (identifier: ContainerIdentifier, options?: Options<"attach">) =>
+            Effect.mapError(
+                HttpApiSocket(
+                    ContainersApi,
+                    "containers",
+                    "attach",
+                    httpClient
+                )({
+                    path: { identifier },
+                    urlParams: { ...options },
+                    headers: { Connection: "Upgrade", Upgrade: "tcp" },
+                }),
+                ContainersError("attach")
             );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerDelete */
-        const delete_ = (
-            id: string,
-            options?:
-                | {
-                      readonly v?: boolean | undefined;
-                      readonly force?: boolean | undefined;
-                      readonly link?: boolean | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.del(`/containers/${encodeURIComponent(id)}`),
-                maybeAddQueryParameter("v", Option.fromNullable(options?.v)),
-                maybeAddQueryParameter("force", Option.fromNullable(options?.force)),
-                maybeAddQueryParameter("link", Option.fromNullable(options?.link)),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "delete", cause }))
+        const attachWebsocket_ = (identifier: ContainerIdentifier, options?: Options<"attachWebsocket">) =>
+            Effect.mapError(
+                HttpApiWebsocket(
+                    ContainersApi,
+                    "containers",
+                    "attachWebsocket"
+                )({ path: { identifier }, urlParams: { ...options } }).pipe(Effect.provide(context)),
+                ContainersError("attachWebsocket")
             );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerArchive */
-        const archive_ = (
-            id: string,
-            options: { readonly path: string }
-        ): Stream.Stream<Uint8Array, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/containers/${encodeURIComponent(id)}/archive`),
-                maybeAddQueryParameter("path", Option.some(options.path)),
-                client.execute,
-                HttpClientResponse.stream,
-                Stream.mapError((cause) => new ContainersError({ method: "archive", cause }))
+        const wait_ = (identifier: ContainerIdentifier, options?: Options<"wait">) =>
+            Effect.mapError(client.wait({ path: { identifier }, urlParams: { ...options } }), ContainersError("wait"));
+        const delete_ = (identifier: ContainerIdentifier, options?: Options<"delete">) =>
+            Effect.mapError(
+                client.delete({ path: { identifier }, urlParams: { ...options } }),
+                ContainersError("delete")
             );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerArchiveInfo */
-        const archiveInfo_ = (
-            id: string,
-            options: { readonly path: string }
-        ): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.head(`/containers/${encodeURIComponent(id)}/archive`),
-                maybeAddQueryParameter("path", Option.some(options.path)),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "archiveInfo", cause }))
+        const archive_ = (identifier: ContainerIdentifier, options: Options<"archive">) =>
+            Stream.mapError(
+                HttpApiStreamingResponse(
+                    ContainersApi,
+                    "containers",
+                    "archive",
+                    httpClient
+                )({ path: { identifier }, urlParams: { ...options } }),
+                ContainersError("archive")
             );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/PutContainerArchive */
-        const putArchive_ = <E1>(
-            id: string,
-            options: {
-                readonly path: string;
-                readonly noOverwriteDirNonDir?: string | undefined;
-                readonly copyUIDGID?: string | undefined;
-                readonly stream: Stream.Stream<Uint8Array, E1, never>;
-            }
-        ): Effect.Effect<void, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.put(`/containers/${encodeURIComponent(id)}/archive`),
-                maybeAddQueryParameter("path", Option.some(options.path)),
-                maybeAddQueryParameter("noOverwriteDirNonDir", Option.fromNullable(options.noOverwriteDirNonDir)),
-                maybeAddQueryParameter("copyUIDGID", Option.fromNullable(options.copyUIDGID)),
-                HttpClientRequest.bodyStream(options.stream),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ContainersError({ method: "putArchive", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Container/operation/ContainerPrune */
-        const prune_ = (
-            options?:
-                | {
-                      readonly filters?:
-                          | {
-                                until?: string;
-                                label?: Record<string, string> | undefined;
-                            }
-                          | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<ContainerPruneResponse, ContainersError, never> =>
-            Function.pipe(
-                HttpClientRequest.post("/containers/prune"),
-                maybeAddFilters(options?.filters),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(ContainerPruneResponse)),
-                Effect.mapError((cause) => new ContainersError({ method: "prune", cause }))
+        const archiveInfo_ = (identifier: ContainerIdentifier, options: Options<"archiveInfo">) =>
+            client
+                .archiveInfo({ path: { identifier }, urlParams: { ...options }, withResponse: true })
+                .pipe(Effect.map(Tuple.getSecond))
+                .pipe(
+                    Effect.flatMap(
+                        HttpClientResponse.schemaHeaders(
+                            Schema.Struct({
+                                "X-Docker-Container-Path-Stat": Schema.compose(
+                                    Schema.StringFromBase64,
+                                    Schema.parseJson()
+                                ).pipe(Schema.optional),
+                            })
+                        )
+                    )
+                )
+                .pipe(Effect.map(({ "X-Docker-Container-Path-Stat": pathStat }) => pathStat))
+                .pipe(Effect.mapError(ContainersError("archiveInfo")));
+        const putArchive_ = <E, R>(
+            identifier: ContainerIdentifier,
+            stream: Stream.Stream<Uint8Array, E, R>,
+            options: Options<"putArchive">
+        ) =>
+            Effect.mapError(
+                HttpApiStreamingRequest(
+                    ContainersApi,
+                    "containers",
+                    "putArchive",
+                    httpClient,
+                    stream
+                )({ path: { identifier }, urlParams: { ...options } }),
+                ContainersError("putArchive")
             );
+        const prune_ = (filters?: Schema.Schema.Type<PruneFilters> | undefined) =>
+            Effect.mapError(client.prune({ urlParams: { filters } }), ContainersError("prune"));
 
         return {
             list: list_,
@@ -607,10 +608,21 @@ export class Containers extends Effect.Service<Containers>()("@the-moby-effect/e
     }),
 }) {}
 
+/**
+ * @since 1.0.0
+ * @category Layers
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Container
+ */
+export const ContainersLayerLocalSocket: Layer.Layer<
+    Containers,
+    never,
+    HttpClient.HttpClient | Socket.WebSocketConstructor
+> = Containers.Default;
+
 /**
  * @since 1.0.0
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Container
  */
 export const ContainersLayer: Layer.Layer<Containers, never, HttpClient.HttpClient | Socket.WebSocketConstructor> =
-    Containers.Default;
+    Containers.DefaultWithoutDependencies;