the-moby-effect 1.48.4 → 1.51.1

package/src/internal/endpoints/images.ts

@@ -1,590 +1,426 @@
-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 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 { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
+import { Effect, Schema, Stream, type Layer } from "effect";
 
+import * as ParseResult from "effect/ParseResult";
+import { MobyConnectionOptions } from "../../MobyConnection.js";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
+import { mapError } from "../convey/sinks.ts";
 import {
-    ContainerConfig,
-    IDResponse,
-    ImageDeleteResponse as ImageDeleteResponseItem,
+    ContainerCreateRequest,
+    ImageDeleteResponse,
     ImageHistoryResponseItem,
-    ImageInspectResponse as ImageInspect,
-    ImagePruneResponse,
-    RegistrySearchResponse as ImageSearchResponseItem,
+    ImageInspectResponse,
     ImageSummary,
     JSONMessage,
+    RegistrySearchResult,
 } from "../generated/index.js";
-import { maybeAddFilters, maybeAddQueryParameter } from "./common.js";
+import { WithRegistryAuthHeader } from "./auth.ts";
+import { DockerError } from "./circular.ts";
+import {
+    BadRequest,
+    Conflict,
+    HttpApiStreamingBoth,
+    HttpApiStreamingResponse,
+    InternalServerError,
+    NotFound,
+} from "./httpApiHacks.js";
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const ImagesErrorTypeId: unique symbol = Symbol.for(
-    "@the-moby-effect/endpoints/ImagesError"
-) as ImagesErrorTypeId;
+/** @since 1.0.0 */
+export class ListFilters extends Schema.parseJson(
+    Schema.Struct({
+        before: Schema.optional(Schema.Array(Schema.String)),
+        dangling: Schema.optional(Schema.BooleanFromString),
+        label: Schema.optional(Schema.Array(Schema.String)),
+        reference: Schema.optional(Schema.Array(Schema.String)),
+        since: Schema.optional(Schema.Array(Schema.String)),
+        until: Schema.optional(Schema.String),
+    })
+) {}
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export type ImagesErrorTypeId = typeof ImagesErrorTypeId;
+/** @since 1.0.0 */
+export class SearchFilters extends Schema.parseJson(
+    Schema.Struct({
+        "is-official": Schema.transformOrFail(Schema.Tuple(Schema.String), Schema.BooleanFromString, {
+            decode: (_fromA, _options, ast) =>
+                ParseResult.fail(
+                    new ParseResult.Forbidden(ast, _fromA, "Decoding 'is-official' filter is not supported")
+                ),
+            encode: (automated) => ParseResult.succeed([automated] as const),
+        }).pipe(Schema.optional),
+        "is-automated": Schema.transformOrFail(Schema.Tuple(Schema.String), Schema.BooleanFromString, {
+            decode: (_fromA, _options, ast) =>
+                ParseResult.fail(
+                    new ParseResult.Forbidden(ast, _fromA, "Decoding 'is-automated' filter is not supported")
+                ),
+            encode: (automated) => ParseResult.succeed([automated] as const),
+        }).pipe(Schema.optional),
+        stars: Schema.optional(Schema.NumberFromString),
+    })
+) {}
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const isImagesError = (u: unknown): u is ImagesError => Predicate.hasProperty(u, ImagesErrorTypeId);
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageList */
+const listImagesEndpoint = HttpApiEndpoint.get("list", "/images/json")
+    .setUrlParams(
+        Schema.Struct({
+            filters: Schema.optional(ListFilters),
+            all: Schema.optional(Schema.BooleanFromString),
+            digests: Schema.optional(Schema.BooleanFromString),
+            "shared-size": Schema.optional(Schema.BooleanFromString),
+        })
+    )
+    .addSuccess(Schema.Array(ImageSummary), { status: 200 });
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export class ImagesError extends PlatformError.TypeIdError(ImagesErrorTypeId, "ImagesError")<{
-    method: string;
-    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
-}> {
-    get message() {
-        return `${this.method}`;
-    }
-}
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageBuild */
+const buildImageEndpoint = HttpApiEndpoint.post("build", "/build")
+    .setUrlParams(
+        Schema.Struct({
+            dockerfile: Schema.optional(Schema.String),
+            t: Schema.optional(Schema.String),
+            extrahosts: Schema.optional(Schema.String),
+            remote: Schema.optional(Schema.String),
+            q: Schema.optional(Schema.BooleanFromString),
+            nocache: Schema.optional(Schema.BooleanFromString),
+            cachefrom: Schema.optional(Schema.String),
+            pull: Schema.optional(Schema.String),
+            rm: Schema.optional(Schema.BooleanFromString),
+            forcerm: Schema.optional(Schema.BooleanFromString),
+            memory: Schema.optional(Schema.NumberFromString),
+            memswap: Schema.optional(Schema.NumberFromString),
+            cpushares: Schema.optional(Schema.NumberFromString),
+            cpusetcpus: Schema.optional(Schema.String),
+            cpuperiod: Schema.optional(Schema.NumberFromString),
+            cpuquota: Schema.optional(Schema.NumberFromString),
+            buildargs: Schema.optional(
+                Schema.parseJson(
+                    Schema.Record({
+                        key: Schema.String,
+                        value: Schema.NullishOr(Schema.String),
+                    })
+                )
+            ),
+            shmsize: Schema.optional(Schema.NumberFromString),
+            squash: Schema.optional(Schema.BooleanFromString),
+            labels: Schema.optional(Schema.String),
+            networkmode: Schema.optional(Schema.String),
+            platform: Schema.optional(Schema.String),
+            target: Schema.optional(Schema.String),
+            outputs: Schema.optional(Schema.String),
+            version: Schema.optional(Schema.Literal("1")),
+        })
+    )
+    .setHeaders(
+        Schema.Struct({
+            "Content-type": Schema.optional(Schema.String),
+            "X-Registry-Config": Schema.optional(Schema.String),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(BadRequest); // 400 Bad parameter
 
-/**
- * @since 1.0.0
- * @category Params
- * @see https://docs.docker.com/reference/api/engine/latest/#tag/Image
- */
-export interface ImageBuildOptions<E1> {
-    /**
-     * A tar archive compressed with one of the following algorithms: identity
-     * (no compression), gzip, bzip2, xz.
-     */
-    readonly context: Stream.Stream<Uint8Array, E1, never>;
-    /**
-     * Path within the build context to the `Dockerfile`. This is ignored if
-     * `remote` is specified and points to an external `Dockerfile`.
-     */
-    readonly dockerfile?: string | undefined;
-    /**
-     * A name and optional tag to apply to the image in the `name:tag` format.
-     * If you omit the tag the default `latest` value is assumed. You can
-     * provide several `t` parameters.
-     */
-    readonly t?: string | undefined;
-    /** Extra hosts to add to /etc/hosts */
-    readonly extrahosts?: string | undefined;
-    /**
-     * A Git repository URI or HTTP/HTTPS context URI. If the URI points to a
-     * single text file, the file’s contents are placed into a file called
-     * `Dockerfile` and the image is built from that file. If the URI points to
-     * a tarball, the file is downloaded by the daemon and the contents therein
-     * used as the context for the build. If the URI points to a tarball and the
-     * `dockerfile` parameter is also specified, there must be a file with the
-     * corresponding path inside the tarball.
-     */
-    readonly remote?: string | undefined;
-    /** Suppress verbose build output. */
-    readonly q?: boolean | undefined;
-    /** Do not use the cache when building the image. */
-    readonly nocache?: boolean | undefined;
-    /** JSON array of images used for build cache resolution. */
-    readonly cachefrom?: string | undefined;
-    /** Attempt to pull the image even if an older image exists locally. */
-    readonly pull?: string | undefined;
-    /** Remove intermediate containers after a successful build. */
-    readonly rm?: boolean | undefined;
-    /** Always remove intermediate containers, even upon failure. */
-    readonly forcerm?: boolean | undefined;
-    /** Set memory limit for build. */
-    readonly memory?: number | undefined;
-    /** Total memory (memory + swap). Set as `-1` to disable swap. */
-    readonly memswap?: number | undefined;
-    /** CPU shares (relative weight). */
-    readonly cpushares?: number | undefined;
-    /** CPUs in which to allow execution (e.g., `0-3`, `0,1`). */
-    readonly cpusetcpus?: string | undefined;
-    /** The length of a CPU period in microseconds. */
-    readonly cpuperiod?: number | undefined;
-    /** Microseconds of CPU time that the container can get in a CPU period. */
-    readonly cpuquota?: number | undefined;
-    /**
-     * JSON map of string pairs for build-time variables. Users pass these
-     * values at build-time. Docker uses the buildargs as the environment
-     * context for commands run via the `Dockerfile` RUN instruction, or for
-     * variable expansion in other `Dockerfile` instructions. This is not meant
-     * for passing secret values.
-     *
-     * For example, the build arg `FOO=bar` would become `{"FOO":"bar"}` in
-     * JSON. This would result in the query parameter `buildargs={"FOO":"bar"}`.
-     * Note that `{"FOO":"bar"}` should be URI component encoded.
-     *
-     * [Read more about the buildargs
-     * instruction.](https://docs.docker.com/engine/reference/builder/#arg)
-     */
-    readonly buildArgs?: Record<string, string | undefined> | undefined;
-    /**
-     * Size of `/dev/shm` in bytes. The size must be greater than 0. If omitted
-     * the system uses 64MB.
-     */
-    readonly shmsize?: number | undefined;
-    /**
-     * Squash the resulting images layers into a single layer. _(Experimental
-     * release only.)_
-     */
-    readonly squash?: boolean | undefined;
-    /**
-     * Arbitrary key/value labels to set on the image, as a JSON map of string
-     * pairs.
-     */
-    readonly labels?: string | undefined;
-    /**
-     * Sets the networking mode for the run commands during build. Supported
-     * standard values are: `bridge`, `host`, `none`, and `container:<name|id>`.
-     * Any other value is taken as a custom network's name or ID to which this
-     * container should connect to.
-     */
-    readonly networkmode?: string | undefined;
-    readonly "Content-type"?: string | undefined;
-    /**
-     * This is a base64-encoded JSON object with auth configurations for
-     * multiple registries that a build may refer to.
-     *
-     * The key is a registry URL, and the value is an auth configuration object,
-     * [as described in the authentication section](#section/Authentication).
-     * For example:
-     *
-     *     {
-     *         "docker.example.com": {
-     *             "username": "janedoe",
-     *             "password": "hunter2"
-     *         },
-     *         "https://index.docker.io/v1/": {
-     *             "username": "mobydock",
-     *             "password": "conta1n3rize14"
-     *         }
-     *     }
-     *
-     * Only the registry domain name (and port if not the default 443) are
-     * required. However, for legacy reasons, the Docker Hub registry must be
-     * specified with both a `https://` prefix and a `/v1/` suffix even though
-     * Docker will prefer to use the v2 registry API.
-     */
-    readonly "X-Registry-Config"?: string | undefined;
-    /** Platform in the format os[/arch[/variant]] */
-    readonly platform?: string | undefined;
-    /** Target build stage */
-    readonly target?: string | undefined;
-    /** BuildKit output configuration */
-    readonly outputs?: string | undefined;
-}
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/BuildPrune */
+const buildPruneEndpoint = HttpApiEndpoint.post("buildPrune", "/build/prune")
+    .setUrlParams(
+        Schema.Struct({
+            "keep-storage": Schema.optional(Schema.NumberFromString),
+            all: Schema.optional(Schema.BooleanFromString),
+            filters: Schema.optional(Schema.String),
+        })
+    )
+    .addSuccess(
+        Schema.Struct({
+            SpaceReclaimed: Schema.Number,
+            CachesDeleted: Schema.Array(Schema.String),
+        }),
+        { status: 200 }
+    );
 
-/**
- * Images service
- *
- * @since 1.0.0
- * @category Tags
- */
-export class Images extends Effect.Service<Images>()("@the-moby-effect/endpoints/Images", {
-    accessors: false,
-    dependencies: [],
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageCreate */
+const createImageEndpoint = HttpApiEndpoint.post("create", "/images/create")
+    .setUrlParams(
+        Schema.Struct({
+            fromImage: Schema.optional(Schema.String),
+            fromSrc: Schema.optional(Schema.String),
+            repo: Schema.optional(Schema.String),
+            tag: Schema.optional(Schema.String),
+            message: Schema.optional(Schema.String),
+            changes: Schema.optional(Schema.String),
+            platform: Schema.optional(Schema.String),
+        })
+    )
+    .setHeaders(Schema.Struct({ "X-Registry-Auth": Schema.optional(Schema.String) }))
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(NotFound); // 404 Repository not found or no read access
 
-    effect: Effect.gen(function* () {
-        const defaultClient = yield* HttpClient.HttpClient;
-        const client = defaultClient.pipe(HttpClient.filterStatusOk);
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageInspect */
+const inspectImageEndpoint = HttpApiEndpoint.get("inspect", "/images/:name/json")
+    .setPath(Schema.Struct({ name: Schema.String }))
+    .setUrlParams(Schema.Struct({ manifests: Schema.optional(Schema.BooleanFromString) }))
+    .addSuccess(ImageInspectResponse, { status: 200 })
+    .addError(NotFound); // 404 No such image
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageList */
-        const list_ = (
-            options?:
-                | {
-                      /**
-                       * Show all images. Only images from a final layer (no
-                       * children) are shown by default.
-                       */
-                      readonly all?: boolean;
-                      /**
-                       * A JSON encoded value of the filters (a
-                       * `map[string][]string`) to process on the images list.
-                       *
-                       * Available filters:
-                       *
-                       * - `before`=(`<image-name>[:<tag>]`, `<image id>` or
-                       *   `<image@digest>`)
-                       * - `dangling=true`
-                       * - `label=key` or `label="key=value"` of an image label
-                       * - `reference`=(`<image-name>[:<tag>]`)
-                       * - `since`=(`<image-name>[:<tag>]`, `<image id>` or
-                       *   `<image@digest>`)
-                       * - `until=<timestamp>`
-                       */
-                      readonly filters?: string | undefined;
-                      /**
-                       * Compute and show shared size as a `SharedSize` field on
-                       * each image.
-                       */
-                      readonly "shared-size"?: boolean | undefined;
-                      /**
-                       * Show digest information as a `RepoDigests` field on
-                       * each image.
-                       */
-                      readonly digests?: boolean | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<ReadonlyArray<ImageSummary>, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.get("/images/json"),
-                maybeAddQueryParameter("all", Option.fromNullable(options?.all)),
-                maybeAddQueryParameter("filters", Option.fromNullable(options?.filters)),
-                maybeAddQueryParameter("shared-size", Option.fromNullable(options?.["shared-size"])),
-                maybeAddQueryParameter("digests", Option.fromNullable(options?.digests)),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(ImageSummary))),
-                Effect.mapError((cause) => new ImagesError({ method: "list", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageHistory */
+const historyImageEndpoint = HttpApiEndpoint.get("history", "/images/:name/history")
+    .setPath(Schema.Struct({ name: Schema.String }))
+    .setUrlParams(Schema.Struct({ platform: Schema.optional(Schema.String) }))
+    .addSuccess(Schema.Array(ImageHistoryResponseItem), { status: 200 })
+    .addError(NotFound); // 404 No such image
 
-        /**
-         * TODO: This needs to error if the build failed
-         *
-         * @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageBuild
-         */
-        const build_ = <E1>(options: ImageBuildOptions<E1>): Stream.Stream<JSONMessage, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/build`),
-                HttpClientRequest.setHeader("Content-type", options["Content-type"] ?? "application/x-tar"),
-                HttpClientRequest.setHeader("X-Registry-Config", options["X-Registry-Config"] ?? ""),
-                maybeAddQueryParameter("dockerfile", Option.fromNullable(options.dockerfile)),
-                maybeAddQueryParameter("t", Option.fromNullable(options.t)),
-                maybeAddQueryParameter("extrahosts", Option.fromNullable(options.extrahosts)),
-                maybeAddQueryParameter("remote", Option.fromNullable(options.remote)),
-                maybeAddQueryParameter("q", Option.fromNullable(options.q)),
-                maybeAddQueryParameter("nocache", Option.fromNullable(options.nocache)),
-                maybeAddQueryParameter("cachefrom", Option.fromNullable(options.cachefrom)),
-                maybeAddQueryParameter("pull", Option.fromNullable(options.pull)),
-                maybeAddQueryParameter("rm", Option.fromNullable(options.rm)),
-                maybeAddQueryParameter("forcerm", Option.fromNullable(options.forcerm)),
-                maybeAddQueryParameter("memory", Option.fromNullable(options.memory)),
-                maybeAddQueryParameter("memswap", Option.fromNullable(options.memswap)),
-                maybeAddQueryParameter("cpushares", Option.fromNullable(options.cpushares)),
-                maybeAddQueryParameter("cpusetcpus", Option.fromNullable(options.cpusetcpus)),
-                maybeAddQueryParameter("cpuperiod", Option.fromNullable(options.cpuperiod)),
-                maybeAddQueryParameter("cpuquota", Option.fromNullable(options.cpuquota))
-            ).pipe(
-                maybeAddQueryParameter("buildargs", Option.fromNullable(JSON.stringify(options.buildArgs))),
-                maybeAddQueryParameter("shmsize", Option.fromNullable(options.shmsize)),
-                maybeAddQueryParameter("squash", Option.fromNullable(options.squash)),
-                maybeAddQueryParameter("labels", Option.fromNullable(options.labels)),
-                maybeAddQueryParameter("networkmode", Option.fromNullable(options.networkmode)),
-                maybeAddQueryParameter("platform", Option.fromNullable(options.platform)),
-                maybeAddQueryParameter("target", Option.fromNullable(options.target)),
-                maybeAddQueryParameter("outputs", Option.fromNullable(options.outputs)),
-                maybeAddQueryParameter("version", Option.some("1")),
-                HttpClientRequest.bodyStream(options.context),
-                client.execute,
-                HttpClientResponse.stream,
-                Stream.decodeText(),
-                Stream.splitLines,
-                Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))),
-                Stream.mapError((cause) => new ImagesError({ method: "build", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImagePush */
+const pushImageEndpoint = HttpApiEndpoint.post("push", "/images/:name/push")
+    .setPath(Schema.Struct({ name: Schema.String }))
+    .setUrlParams(Schema.Struct({ tag: Schema.optional(Schema.String), platform: Schema.optional(Schema.String) }))
+    .setHeaders(Schema.Struct({ "X-Registry-Auth": Schema.optional(Schema.String) }))
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(NotFound); // 404 No such image
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/BuildPrune */
-        const buildPrune_ = (
-            options?:
-                | {
-                      readonly "keep-storage"?: number;
-                      readonly all?: boolean;
-                      readonly filters?:
-                          | {
-                                until?: string | undefined;
-                                id?: string | undefined;
-                                parent?: string | undefined;
-                                type?: string | undefined;
-                                description?: string | undefined;
-                                inuse?: boolean | undefined;
-                                shared?: boolean | undefined;
-                                private?: boolean | undefined;
-                            }
-                          | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<ImagePruneResponse, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.post("/build/prune"),
-                maybeAddQueryParameter("keep-storage", Option.fromNullable(options?.["keep-storage"])),
-                maybeAddQueryParameter("all", Option.fromNullable(options?.all)),
-                maybeAddFilters(options?.filters),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(ImagePruneResponse)),
-                Effect.mapError((cause) => new ImagesError({ method: "buildPrune", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageTag */
+const tagImageEndpoint = HttpApiEndpoint.post("tag", "/images/:name/tag")
+    .setPath(Schema.Struct({ name: Schema.String }))
+    .setUrlParams(Schema.Struct({ repo: Schema.optional(Schema.String), tag: Schema.optional(Schema.String) }))
+    .addSuccess(HttpApiSchema.Empty(201))
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(NotFound) // 404 No such image
+    .addError(Conflict); // 409 Conflict
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageCreate */
-        const create_ = (options: {
-            /**
-             * Name of the image to pull. The name may include a tag or digest.
-             * This parameter may only be used when pulling an image. The pull
-             * is cancelled if the HTTP connection is closed.
-             */
-            readonly fromImage?: string | undefined;
-            /**
-             * Source to import. The value may be a URL from which the image can
-             * be retrieved or `-` to read the image from the request body. This
-             * parameter may only be used when importing an image.
-             */
-            readonly fromSrc?: string | undefined;
-            /**
-             * Repository name given to an image when it is imported. The repo
-             * may include a tag. This parameter may only be used when importing
-             * an image.
-             */
-            readonly repo?: string | undefined;
-            /**
-             * Tag or digest. If empty when pulling an image, this causes all
-             * tags for the given image to be pulled.
-             */
-            readonly tag?: string | undefined;
-            /** Set commit message for imported image. */
-            readonly message?: string | undefined;
-            /**
-             * Image content if the value `-` has been specified in fromSrc
-             * query parameter
-             */
-            readonly inputImage?: string | undefined;
-            /**
-             * A base64url-encoded auth configuration.
-             *
-             * Refer to the [authentication section](#section/Authentication)
-             * for details.
-             */
-            readonly "X-Registry-Auth"?: string | undefined;
-            /**
-             * Apply `Dockerfile` instructions to the image that is created, for
-             * example: `changes=ENV DEBUG=true`. Note that `ENV DEBUG=true`
-             * should be URI component encoded.
-             *
-             * Supported `Dockerfile` instructions:
-             * `CMD`|`ENTRYPOINT`|`ENV`|`EXPOSE`|`ONBUILD`|`USER`|`VOLUME`|`WORKDIR`
-             */
-            readonly changes?: string | undefined;
-            /**
-             * Platform in the format os[/arch[/variant]].
-             *
-             * When used in combination with the `fromImage` option, the daemon
-             * checks if the given image is present in the local image cache
-             * with the given OS and Architecture, and otherwise attempts to
-             * pull the image. If the option is not set, the host's native OS
-             * and Architecture are used. If the given image does not exist in
-             * the local image cache, the daemon attempts to pull the image with
-             * the host's native OS and Architecture. If the given image does
-             * exists in the local image cache, but its OS or architecture does
-             * not match, a warning is produced.
-             *
-             * When used with the `fromSrc` option to import an image from an
-             * archive, this option sets the platform information for the
-             * imported image. If the option is not set, the host's native OS
-             * and Architecture are used for the imported image.
-             */
-            readonly platform?: string | undefined;
-        }): Stream.Stream<JSONMessage, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.post("/images/create"),
-                HttpClientRequest.setHeader("X-Registry-Auth", options["X-Registry-Auth"] || ""),
-                maybeAddQueryParameter("fromImage", Option.fromNullable(options.fromImage)),
-                maybeAddQueryParameter("fromSrc", Option.fromNullable(options.fromSrc)),
-                maybeAddQueryParameter("repo", Option.fromNullable(options.repo)),
-                maybeAddQueryParameter("tag", Option.fromNullable(options.tag)),
-                maybeAddQueryParameter("message", Option.fromNullable(options.message)),
-                maybeAddQueryParameter("changes", Option.fromNullable(options.changes)),
-                maybeAddQueryParameter("platform", Option.fromNullable(options.platform)),
-                HttpClientRequest.bodyText(options.inputImage ?? ""),
-                client.execute,
-                HttpClientResponse.stream,
-                Stream.decodeText(),
-                Stream.splitLines,
-                Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))),
-                Stream.mapError((cause) => new ImagesError({ method: "create", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageDelete */
+const deleteImageEndpoint = HttpApiEndpoint.del("delete", "/images/:name")
+    .setPath(Schema.Struct({ name: Schema.String }))
+    .setUrlParams(
+        Schema.Struct({
+            force: Schema.optional(Schema.BooleanFromString),
+            noprune: Schema.optional(Schema.BooleanFromString),
+            platforms: Schema.optional(Schema.Array(Schema.String)),
+        })
+    )
+    .addSuccess(Schema.Array(ImageDeleteResponse), { status: 200 })
+    .addError(NotFound) // 404 No such image
+    .addError(Conflict); // 409 Conflict
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageInspect */
-        const inspect_ = (options: {
-            readonly name: string;
-        }): Effect.Effect<Readonly<ImageInspect>, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/images/${encodeURIComponent(options.name)}/json`),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(ImageInspect)),
-                Effect.mapError((cause) => new ImagesError({ method: "inspect", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageSearch */
+const searchImagesEndpoint = HttpApiEndpoint.get("search", "/images/search")
+    .setUrlParams(
+        Schema.Struct({
+            term: Schema.String,
+            limit: Schema.optional(Schema.NumberFromString),
+            filters: Schema.optional(SearchFilters),
+        })
+    )
+    .addSuccess(Schema.Array(RegistrySearchResult), { status: 200 });
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageHistory */
-        const history_ = (options: {
-            readonly name: string;
-        }): Effect.Effect<ReadonlyArray<ImageHistoryResponseItem>, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/images/${encodeURIComponent(options.name)}/history`),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(ImageHistoryResponseItem))),
-                Effect.mapError((cause) => new ImagesError({ method: "history", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImagePrune */
+const pruneImagesEndpoint = HttpApiEndpoint.post("prune", "/images/prune")
+    .setUrlParams(
+        Schema.Struct({
+            filters: Schema.optional(Schema.String),
+        })
+    )
+    .addSuccess(
+        Schema.Struct({
+            SpaceReclaimed: Schema.Number,
+            ImagesDeleted: Schema.NullishOr(Schema.Array(ImageDeleteResponse)),
+        }),
+        { status: 200 }
+    );
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImagePush */
-        const push_ = (options: {
-            readonly name: string;
-            readonly tag?: string;
-            readonly "X-Registry-Auth": string;
-        }): Stream.Stream<string, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/images/${encodeURIComponent(options.name)}/push`),
-                HttpClientRequest.setHeader("X-Registry-Auth", options["X-Registry-Auth"]),
-                maybeAddQueryParameter("tag", Option.fromNullable(options.tag)),
-                client.execute,
-                HttpClientResponse.stream,
-                Stream.decodeText(),
-                Stream.mapError((cause) => new ImagesError({ method: "push", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageCommit */
+const commitImageEndpoint = HttpApiEndpoint.post("commit", "/images/commit")
+    .setUrlParams(
+        Schema.Struct({
+            container: Schema.String,
+            repo: Schema.optional(Schema.String),
+            tag: Schema.optional(Schema.String),
+            comment: Schema.optional(Schema.String),
+            author: Schema.optional(Schema.String),
+            pause: Schema.optional(Schema.BooleanFromString),
+            changes: Schema.optional(Schema.String),
+        })
+    )
+    .setPayload(ContainerCreateRequest)
+    .addSuccess(ImageInspectResponse, { status: 201 })
+    .addError(NotFound); // 404 No such container
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageTag */
-        const tag_ = (options: {
-            readonly name: string;
-            readonly repo?: string;
-            readonly tag?: string;
-        }): Effect.Effect<void, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/images/${encodeURIComponent(options.name)}/tag`),
-                maybeAddQueryParameter("repo", Option.fromNullable(options.repo)),
-                maybeAddQueryParameter("tag", Option.fromNullable(options.tag)),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ImagesError({ method: "tag", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageGet */
+const exportImageEndpoint = HttpApiEndpoint.get("export", "/images/:name/get")
+    .setPath(Schema.Struct({ name: Schema.String }))
+    .setUrlParams(Schema.Struct({ platform: Schema.optional(Schema.String) }))
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(NotFound); // 404 No such image
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageDelete */
-        const delete_ = (options: {
-            readonly name: string;
-            readonly force?: boolean;
-            readonly noprune?: boolean;
-        }): Effect.Effect<ReadonlyArray<ImageDeleteResponseItem>, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.del(`/images/${encodeURIComponent(options.name)}`),
-                maybeAddQueryParameter("force", Option.fromNullable(options.force)),
-                maybeAddQueryParameter("noprune", Option.fromNullable(options.noprune)),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(ImageDeleteResponseItem))),
-                Effect.mapError((cause) => new ImagesError({ method: "delete", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageGetAll */
+const exportManyImagesEndpoint = HttpApiEndpoint.get("exportMany", "/images/get")
+    .setUrlParams(Schema.Struct({ names: Schema.optional(Schema.String) }))
+    .setUrlParams(Schema.Struct({ platform: Schema.optional(Schema.String) }))
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(NotFound); // 404 No such image
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageSearch */
-        const search_ = (options: {
-            readonly term: string;
-            readonly limit?: number | undefined;
-            readonly stars?: number | undefined;
-            readonly "is-official"?: boolean | undefined;
-        }): Effect.Effect<ReadonlyArray<ImageSearchResponseItem>, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.get("/images/search"),
-                maybeAddQueryParameter("term", Option.some(options.term)),
-                maybeAddQueryParameter("limit", Option.fromNullable(options.limit)),
-                maybeAddFilters({ stars: options.stars, "is-official": options["is-official"] }),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(ImageSearchResponseItem))),
-                Effect.mapError((cause) => new ImagesError({ method: "search", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageLoad */
+const importImageEndpoint = HttpApiEndpoint.post("import", "/images/load")
+    .setUrlParams(
+        Schema.Struct({
+            platform: Schema.optional(Schema.String),
+            quiet: Schema.optional(Schema.BooleanFromString),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(BadRequest); // 400 Bad parameter
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImagePrune */
-        const prune_ = (
-            options?:
-                | {
-                      readonly filters?: {
-                          dangling?: ["true" | "false"] | undefined;
-                          until?: [string] | undefined;
-                          label?: Array<string> | undefined;
-                      };
-                  }
-                | undefined
-        ): Effect.Effect<ImagePruneResponse, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.post("/images/prune"),
-                maybeAddQueryParameter(
-                    "filters",
-                    Function.pipe(options?.filters, Option.fromNullable, Option.map(JSON.stringify))
-                ),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(ImagePruneResponse)),
-                Effect.mapError((cause) => new ImagesError({ method: "prune", cause }))
-            );
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image */
+const ImagesGroup = HttpApiGroup.make("images")
+    .add(listImagesEndpoint)
+    .add(buildImageEndpoint)
+    .add(buildPruneEndpoint)
+    .add(createImageEndpoint)
+    .add(inspectImageEndpoint)
+    .add(historyImageEndpoint)
+    .add(pushImageEndpoint)
+    .add(tagImageEndpoint)
+    .add(deleteImageEndpoint)
+    .add(searchImagesEndpoint)
+    .add(pruneImagesEndpoint)
+    .add(commitImageEndpoint)
+    .add(exportImageEndpoint)
+    .add(exportManyImagesEndpoint)
+    .add(importImageEndpoint)
+    .addError(InternalServerError);
+
+/**
+ * @since 1.0.0
+ * @category HttpApi
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Image
+ */
+export const ImagesApi = HttpApi.make("ImagesApi").add(ImagesGroup);
+
+/**
+ * @since 1.0.0
+ * @category Services
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Image
+ */
+export class Images extends Effect.Service<Images>()("@the-moby-effect/endpoints/Images", {
+    accessors: false,
+    dependencies: [
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        ),
+    ],
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageCommit */
-        const commit_ = (options: {
-            readonly containerConfig: ContainerConfig;
-            readonly container?: string;
-            readonly repo?: string;
-            readonly tag?: string;
-            readonly comment?: string;
-            readonly author?: string;
-            readonly pause?: boolean;
-            readonly changes?: string;
-        }): Effect.Effect<Readonly<IDResponse>, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.post("/images/commit"),
-                maybeAddQueryParameter("container", Option.fromNullable(options.container)),
-                maybeAddQueryParameter("repo", Option.fromNullable(options.repo)),
-                maybeAddQueryParameter("tag", Option.fromNullable(options.tag)),
-                maybeAddQueryParameter("comment", Option.fromNullable(options.comment)),
-                maybeAddQueryParameter("author", Option.fromNullable(options.author)),
-                maybeAddQueryParameter("pause", Option.fromNullable(options.pause)),
-                maybeAddQueryParameter("changes", Option.fromNullable(options.changes)),
-                HttpClientRequest.schemaBodyJson(ContainerConfig)(options.containerConfig),
-                Effect.flatMap(client.execute),
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(IDResponse)),
-                Effect.mapError((cause) => new ImagesError({ method: "commit", cause }))
-            );
+    effect: Effect.gen(function* () {
+        type Options<Name extends (typeof ImagesGroup.endpoints)[number]["name"]> =
+            HttpApiEndpoint.HttpApiEndpoint.UrlParams<
+                HttpApiEndpoint.HttpApiEndpoint.WithName<(typeof ImagesGroup.endpoints)[number], Name>
+            >;
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageGet */
-        const get_ = (options: { readonly name: string }): Stream.Stream<string, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/images/${encodeURIComponent(options.name)}/get`),
-                client.execute,
-                HttpClientResponse.stream,
-                Stream.decodeText(),
-                Stream.mapError((cause) => new ImagesError({ method: "get", cause }))
-            );
+        const httpClient = yield* Effect.map(
+            HttpClient.HttpClient,
+            WithRegistryAuthHeader(buildImageEndpoint, createImageEndpoint, pushImageEndpoint)
+        );
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageGetAll */
-        const getall_ = (
-            options?: { readonly names?: Array<string> | undefined } | undefined
-        ): Stream.Stream<string, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.get("/images/get"),
-                maybeAddQueryParameter("names", Option.fromNullable(options?.names)),
-                client.execute,
-                HttpClientResponse.stream,
-                Stream.decodeText(),
-                Stream.mapError((cause) => new ImagesError({ method: "getall", cause }))
-            );
+        const ImagesError = DockerError.WrapForModule("images");
+        const client = yield* HttpApiClient.group(ImagesApi, { group: "images", httpClient });
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Image/operation/ImageLoad */
-        const load_ = <E1>(options: {
-            readonly imagesTarball: Stream.Stream<Uint8Array, E1, never>;
-            readonly quiet?: boolean;
-        }): Effect.Effect<void, ImagesError, never> =>
-            Function.pipe(
-                HttpClientRequest.post("/images/load"),
-                maybeAddQueryParameter("quiet", Option.fromNullable(options?.quiet)),
-                HttpClientRequest.bodyStream(options.imagesTarball),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ImagesError({ method: "load", cause }))
-            );
+        const list_ = (options?: Options<"list">) =>
+            Effect.mapError(client.list({ urlParams: { ...options } }), ImagesError("list"));
+        const build_ = <E1>(context: Stream.Stream<Uint8Array, E1, never>, options?: Options<"build">) =>
+            HttpApiStreamingBoth(
+                ImagesApi,
+                "images",
+                "build",
+                httpClient,
+                context
+            )({
+                urlParams: { ...options },
+                headers: { "Content-type": "application/tar" },
+            })
+                .pipe(Stream.decodeText())
+                .pipe(Stream.splitLines)
+                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
+                .pipe(mapError)
+                .pipe(Stream.mapError(ImagesError("build")));
+        const buildPrune_ = (options?: Options<"buildPrune">) =>
+            Effect.mapError(client.buildPrune({ urlParams: { ...options } }), ImagesError("buildPrune"));
+        const create_ = (options?: Options<"create">) =>
+            HttpApiStreamingResponse(
+                ImagesApi,
+                "images",
+                "create",
+                httpClient
+            )({
+                headers: {},
+                urlParams: { ...options },
+            })
+                .pipe(Stream.decodeText())
+                .pipe(Stream.splitLines)
+                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
+                .pipe(mapError)
+                .pipe(Stream.mapError(ImagesError("create")));
+        const inspect_ = (name: string, options?: Options<"inspect">) =>
+            Effect.mapError(client.inspect({ path: { name }, urlParams: { ...options } }), ImagesError("inspect"));
+        const history_ = (name: string, options?: Options<"history">) =>
+            Effect.mapError(client.history({ path: { name }, urlParams: { ...options } }), ImagesError("history"));
+        const push_ = (name: string, options?: Options<"push">) =>
+            HttpApiStreamingResponse(
+                ImagesApi,
+                "images",
+                "push",
+                httpClient
+            )({
+                path: { name },
+                urlParams: { ...options },
+                headers: {},
+            })
+                .pipe(Stream.decodeText())
+                .pipe(Stream.splitLines)
+                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
+                .pipe(mapError)
+                .pipe(Stream.mapError(ImagesError("push")));
+        const tag_ = (name: string, options?: Options<"tag">) =>
+            Effect.mapError(client.tag({ path: { name }, urlParams: { ...options } }), ImagesError("tag"));
+        const delete_ = (name: string, options?: Options<"delete">) =>
+            Effect.mapError(client.delete({ path: { name }, urlParams: { ...options } }), ImagesError("delete"));
+        const search_ = (options: Options<"search">) =>
+            Effect.mapError(client.search({ urlParams: { ...options } }), ImagesError("search"));
+        const prune_ = (options?: Options<"prune">) =>
+            Effect.mapError(client.prune({ urlParams: { ...options } }), ImagesError("prune"));
+        const commit_ = (payload: ContainerCreateRequest, options: Options<"commit">) =>
+            Effect.mapError(client.commit({ urlParams: { ...options }, payload }), ImagesError("commit"));
+        const export_ = (name: string, options?: Options<"export">) =>
+            HttpApiStreamingResponse(
+                ImagesApi,
+                "images",
+                "export",
+                httpClient
+            )({ path: { name }, urlParams: { ...options } })
+                .pipe(Stream.decodeText())
+                .pipe(Stream.splitLines)
+                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
+                .pipe(mapError)
+                .pipe(Stream.mapError(ImagesError("export")));
+        const exportMany_ = (options?: Options<"exportMany">) =>
+            HttpApiStreamingResponse(
+                ImagesApi,
+                "images",
+                "exportMany",
+                httpClient
+            )({ urlParams: { ...options } })
+                .pipe(Stream.decodeText())
+                .pipe(Stream.splitLines)
+                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
+                .pipe(mapError)
+                .pipe(Stream.mapError(ImagesError("exportMany")));
+        const import_ = <E>(context: Stream.Stream<Uint8Array, E, never>, options?: Options<"import">) =>
+            HttpApiStreamingBoth(
+                ImagesApi,
+                "images",
+                "import",
+                httpClient,
+                context
+            )({ urlParams: { ...options } })
+                .pipe(Stream.decodeText())
+                .pipe(Stream.splitLines)
+                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
+                .pipe(mapError)
+                .pipe(Stream.mapError(ImagesError("import")));
 
         return {
             list: list_,
@@ -599,16 +435,23 @@ export class Images extends Effect.Service<Images>()("@the-moby-effect/endpoints
             search: search_,
             prune: prune_,
             commit: commit_,
-            get: get_,
-            getall: getall_,
-            load: load_,
+            export: export_,
+            exportMany: exportMany_,
+            import: import_,
         };
     }),
 }) {}
 
 /**
  * @since 1.0.0
- * @category Layers
+ * @category Services
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Image
+ */
+export const ImagesLayerLocalSocket: Layer.Layer<Images, never, HttpClient.HttpClient> = Images.Default;
+
+/**
+ * @since 1.0.0
+ * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Image
  */
-export const ImagesLayer: Layer.Layer<Images, never, HttpClient.HttpClient> = Images.Default;
+export const ImagesLayer: Layer.Layer<Images, never, HttpClient.HttpClient> = Images.DefaultWithoutDependencies;