the-moby-effect 1.51.6 → 1.54.1

package/dist/internal/endpoints/containers.d.ts

@@ -1,196 +1,313 @@
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpClient, type Socket } from "@effect/platform";
-import { Effect, Schema, Stream, type Layer } from "effect";
-import { ArchiveChange, ContainerConfig, ContainerCreateRequest, ContainerHostConfig, ContainerInspectResponse, ContainerStatsResponse, ContainerSummary, ContainerTopResponse, ContainerWaitResponse } from "../generated/index.js";
-import { ContainerIdentifier } from "../schemas/id.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
+import * as Socket from "effect/unstable/socket/Socket";
+import { ArchiveChange, ContainerConfig, ContainerCreateRequest, ContainerHostConfig, ContainerInspectResponse, ContainerStatsResponse, ContainerSummary, ContainerTopResponse, ContainerWaitResponse } from "../generated/index.ts";
+import { ContainerIdentifier } from "../schemas/id.ts";
 import { DockerError } from "./circular.ts";
-import { BadRequest, Conflict, Forbidden, InternalServerError, NotAcceptable, NotFound } from "./httpApiHacks.js";
-declare const ListFilters_base: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
-    ancestor: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    before: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    expose: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    exited: Schema.optional<Schema.Array$<typeof Schema.NumberFromString>>;
-    health: Schema.optional<Schema.Array$<Schema.Literal<["none", "starting", "healthy", "unhealthy"]>>>;
-    identifier: Schema.optional<Schema.Array$<Schema.brand<typeof Schema.String, "ContainerId">>>;
-    "is-task": Schema.optional<typeof Schema.BooleanFromString>;
-    label: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    name: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    network: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    publish: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    since: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    status: Schema.optional<Schema.Array$<Schema.Literal<["created", "restarting", "running", "removing", "paused", "exited", "dead"]>>>;
-    volume: Schema.optional<typeof Schema.String>;
-}>>;
+import { BadRequest, Conflict, Forbidden, InternalServerError, NotAcceptable, NotFound } from "./errors.ts";
 /** @since 1.0.0 */
-export declare class ListFilters extends ListFilters_base {
-}
-declare const PruneFilters_base: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
-    until: Schema.optional<typeof Schema.String>;
-    label: Schema.optional<Schema.Array$<typeof Schema.String>>;
+export declare const ListFilters: Schema.fromJsonString<Schema.Struct<{
+    readonly ancestor: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly before: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly expose: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly exited: Schema.optional<Schema.$Array<Schema.NumberFromString>>;
+    readonly health: Schema.optional<Schema.$Array<Schema.Literals<readonly ["none", "starting", "healthy", "unhealthy"]>>>;
+    readonly identifier: Schema.optional<Schema.$Array<Schema.brand<Schema.String, "ContainerId">>>;
+    readonly "is-task": Schema.optional<Schema.decodeTo<Schema.Boolean, Schema.Tuple<readonly [Schema.String]>, never, never>>;
+    readonly label: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly name: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly network: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly publish: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly since: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly status: Schema.optional<Schema.$Array<Schema.Literals<readonly ["created", "restarting", "running", "removing", "paused", "exited", "dead"]>>>;
+    readonly volume: Schema.optional<Schema.decodeTo<Schema.String, Schema.Tuple<readonly [Schema.String]>, never, never>>;
 }>>;
 /** @since 1.0.0 */
-export declare class PruneFilters extends PruneFilters_base {
-}
+export declare const PruneFilters: Schema.fromJsonString<Schema.Struct<{
+    readonly until: Schema.optional<Schema.decodeTo<Schema.String, Schema.Tuple<readonly [Schema.String]>, never, never>>;
+    readonly label: Schema.optional<Schema.$Array<Schema.String>>;
+}>>;
 /**
  * @since 1.0.0
  * @category HttpApi
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Container
  */
-export declare const ContainersApi: HttpApi.HttpApi<"ContainersApi", HttpApiGroup.HttpApiGroup<"containers", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", never, {
-    readonly size?: boolean | undefined;
-    readonly limit?: number | undefined;
-    readonly all?: boolean | undefined;
-    readonly filters?: {
-        readonly identifier?: readonly (string & import("effect/Brand").Brand<"ContainerId">)[] | undefined;
-        readonly volume?: string | undefined;
-        readonly exited?: readonly number[] | undefined;
-        readonly name?: readonly string[] | undefined;
-        readonly status?: readonly ("created" | "restarting" | "running" | "removing" | "paused" | "exited" | "dead")[] | undefined;
-        readonly network?: readonly string[] | undefined;
-        readonly label?: readonly string[] | undefined;
-        readonly ancestor?: readonly string[] | undefined;
-        readonly before?: readonly string[] | undefined;
-        readonly expose?: readonly string[] | undefined;
-        readonly health?: readonly ("none" | "starting" | "healthy" | "unhealthy")[] | undefined;
-        readonly "is-task"?: boolean | undefined;
-        readonly publish?: readonly string[] | undefined;
-        readonly since?: readonly string[] | undefined;
-    } | undefined;
-}, never, never, readonly ContainerSummary[], BadRequest, never, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", never, {
-    readonly platform?: string | undefined;
-    readonly name?: string | undefined;
-}, ContainerCreateRequest, never, {
-    readonly Id: string & import("effect/Brand").Brand<"ContainerId">;
-    readonly Warnings: readonly string[] | null;
-}, BadRequest | Forbidden | NotFound | NotAcceptable | Conflict, never, never> | HttpApiEndpoint.HttpApiEndpoint<"inspect", "GET", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly size?: boolean | undefined;
-}, never, never, ContainerInspectResponse, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"top", "GET", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly ps_args?: string | undefined;
-}, never, never, ContainerTopResponse, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"logs", "GET", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly stdout?: boolean | undefined;
-    readonly stderr?: boolean | undefined;
-    readonly since?: number | undefined;
-    readonly until?: number | undefined;
-    readonly follow?: boolean | undefined;
-    readonly timestamps?: boolean | undefined;
-    readonly tail?: string | undefined;
-}, never, never, void, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"changes", "GET", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, never, never, never, readonly ArchiveChange[] | null, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"export", "GET", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, never, never, never, void, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"stats", "GET", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly stream?: boolean | undefined;
-    readonly "one-shot"?: boolean | undefined;
-}, never, never, void, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"resize", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly h?: number | undefined;
-    readonly w?: number | undefined;
-}, never, never, void, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"start", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly detachKeys?: string | undefined;
-}, never, never, void, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"stop", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly signal?: string | undefined;
-    readonly t?: number | undefined;
-}, never, never, void, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"restart", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly signal?: string | undefined;
-    readonly t?: number | undefined;
-}, never, never, void, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"kill", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly signal?: string | undefined;
-}, never, never, void, NotFound | Conflict, never, never> | HttpApiEndpoint.HttpApiEndpoint<"update", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, never, ContainerConfig, never, {
-    readonly Warnings: readonly string[] | null;
-}, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"rename", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly name: string;
-}, never, never, void, NotFound | Conflict, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pause", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, never, never, never, void, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"unpause", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, never, never, never, void, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"attach", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly stream?: boolean | undefined;
-    readonly stdout?: boolean | undefined;
-    readonly stderr?: boolean | undefined;
-    readonly stdin?: boolean | undefined;
-    readonly logs?: boolean | undefined;
-    readonly detachKeys?: string | undefined;
-}, never, {
-    readonly Upgrade: "tcp";
-    readonly Connection: "Upgrade";
-}, void, BadRequest | NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"attachWebsocket", "GET", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly stream?: boolean | undefined;
-    readonly stdout?: boolean | undefined;
-    readonly stderr?: boolean | undefined;
-    readonly stdin?: boolean | undefined;
-    readonly logs?: boolean | undefined;
-    readonly detachKeys?: string | undefined;
-}, never, never, void, BadRequest | NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"wait", "POST", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly condition?: string | undefined;
-}, never, never, ContainerWaitResponse, BadRequest | NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"delete", "DELETE", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly link?: boolean | undefined;
-    readonly force?: boolean | undefined;
-    readonly v?: boolean | undefined;
-}, never, never, void, BadRequest | NotFound | Conflict, never, never> | HttpApiEndpoint.HttpApiEndpoint<"archive", "GET", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly path: string;
-}, never, never, void, BadRequest | NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"archiveInfo", "HEAD", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly path: string;
-}, never, never, void, BadRequest | NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"putArchive", "PUT", {
-    readonly identifier: string & import("effect/Brand").Brand<"ContainerId">;
-}, {
-    readonly path: string;
-    readonly noOverwriteDirNonDir?: string | undefined;
-    readonly copyUIDGidentifier?: string | undefined;
-}, never, never, void, BadRequest | Forbidden | NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"prune", "POST", never, {
-    readonly filters?: {
-        readonly label?: readonly string[] | undefined;
-        readonly until?: string | undefined;
-    } | undefined;
-}, never, never, {
-    readonly ContainersDeleted: readonly (string & import("effect/Brand").Brand<"ContainerId">)[] | null;
-    readonly SpaceReclaimed: bigint & import("effect/Brand").Brand<"I64">;
-}, never, never, never>, InternalServerError, never, false>, import("@effect/platform/HttpApiError").HttpApiDecodeError, never>;
-declare const Containers_base: Effect.Service.Class<Containers, "@the-moby-effect/endpoints/Containers", {
-    readonly accessors: false;
-    readonly dependencies: readonly [Layer.Layer<HttpClient.HttpClient, never, HttpClient.HttpClient>];
-    readonly effect: Effect.Effect<{
+export declare const ContainersApi: HttpApi.HttpApi<"ContainersApi", HttpApiGroup.HttpApiGroup<"containers", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/containers/json", never, Schema.toCodecStringTree<Schema.Struct<{
+    all: Schema.optional<Schema.Boolean>;
+    limit: Schema.optional<Schema.Number>;
+    size: Schema.optional<Schema.Boolean>;
+    filters: Schema.optional<Schema.fromJsonString<Schema.Struct<{
+        readonly ancestor: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly before: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly expose: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly exited: Schema.optional<Schema.$Array<Schema.NumberFromString>>;
+        readonly health: Schema.optional<Schema.$Array<Schema.Literals<readonly ["none", "starting", "healthy", "unhealthy"]>>>;
+        readonly identifier: Schema.optional<Schema.$Array<Schema.brand<Schema.String, "ContainerId">>>;
+        readonly "is-task": Schema.optional<Schema.decodeTo<Schema.Boolean, Schema.Tuple<readonly [Schema.String]>, never, never>>;
+        readonly label: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly name: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly network: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly publish: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly since: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly status: Schema.optional<Schema.$Array<Schema.Literals<readonly ["created", "restarting", "running", "removing", "paused", "exited", "dead"]>>>;
+        readonly volume: Schema.optional<Schema.decodeTo<Schema.String, Schema.Tuple<readonly [Schema.String]>, never, never>>;
+    }>>>;
+}>>, never, never, Schema.toCodecJson<Schema.$Array<typeof ContainerSummary>>, Schema.toCodecJson<typeof BadRequest | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", "/containers/create", never, Schema.toCodecStringTree<Schema.Struct<{
+    platform: Schema.optional<Schema.String>;
+    name: Schema.optional<Schema.String>;
+}>>, Schema.toCodecJson<typeof ContainerCreateRequest>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly Id: Schema.brand<Schema.String, "ContainerId">;
+    readonly Warnings: Schema.NullOr<Schema.$Array<Schema.String>>;
+}>>, Schema.toCodecJson<typeof BadRequest | typeof Forbidden | typeof NotFound | typeof NotAcceptable | typeof Conflict | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"inspect", "GET", "/containers/:identifier/json", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    size: Schema.optional<Schema.Boolean>;
+}>>, never, never, Schema.toCodecJson<typeof ContainerInspectResponse>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"top", "GET", "/containers/:identifier/top", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    ps_args: Schema.optional<Schema.String>;
+}>>, never, never, Schema.toCodecJson<typeof ContainerTopResponse>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"logs", "GET", "/containers/:identifier/logs", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    follow: Schema.optional<Schema.Boolean>;
+    stdout: Schema.optional<Schema.Boolean>;
+    stderr: Schema.optional<Schema.Boolean>;
+    since: Schema.optional<Schema.Number>;
+    until: Schema.optional<Schema.Number>;
+    timestamps: Schema.optional<Schema.Boolean>;
+    tail: Schema.optional<Schema.String>;
+}>>, never, never, HttpApiSchema.StreamUint8Array, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"changes", "GET", "/containers/:identifier/changes", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.NullOr<Schema.$Array<typeof ArchiveChange>>>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"export", "GET", "/containers/:identifier/export", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, never, never, never, HttpApiSchema.StreamUint8Array, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"stats", "GET", "/containers/:identifier/stats", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    stream: Schema.optional<Schema.Boolean>;
+    "one-shot": Schema.optional<Schema.Boolean>;
+}>>, never, never, HttpApiSchema.StreamUint8Array, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"resize", "POST", "/containers/:identifier/resize", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    h: Schema.optional<Schema.Number>;
+    w: Schema.optional<Schema.Number>;
+}>>, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"start", "POST", "/containers/:identifier/start", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    detachKeys: Schema.optional<Schema.String>;
+}>>, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"stop", "POST", "/containers/:identifier/stop", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    signal: Schema.optional<Schema.String>;
+    t: Schema.optional<Schema.Number>;
+}>>, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"restart", "POST", "/containers/:identifier/restart", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    signal: Schema.optional<Schema.String>;
+    t: Schema.optional<Schema.Number>;
+}>>, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"kill", "POST", "/containers/:identifier/kill", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    signal: Schema.optional<Schema.String>;
+}>>, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof NotFound | typeof Conflict | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"update", "POST", "/containers/:identifier/update", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, never, Schema.toCodecJson<typeof ContainerConfig>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly Warnings: Schema.NullOr<Schema.$Array<Schema.String>>;
+}>>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"rename", "POST", "/containers/:identifier/rename", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    name: Schema.String;
+}>>, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof NotFound | typeof Conflict | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pause", "POST", "/containers/:identifier/pause", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"unpause", "POST", "/containers/:identifier/unpause", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"attach", "POST", "/containers/:identifier/attach", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    detachKeys: Schema.optional<Schema.String>;
+    logs: Schema.optional<Schema.Boolean>;
+    stream: Schema.optional<Schema.Boolean>;
+    stdin: Schema.optional<Schema.Boolean>;
+    stdout: Schema.optional<Schema.Boolean>;
+    stderr: Schema.optional<Schema.Boolean>;
+}>>, never, Schema.toCodecStringTree<Schema.Struct<{
+    Upgrade: Schema.Literal<"tcp">;
+    Connection: Schema.Literal<"Upgrade">;
+}>>, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof BadRequest | typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"attachWebsocket", "GET", "/containers/:identifier/attach/ws", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    detachKeys: Schema.optional<Schema.String>;
+    logs: Schema.optional<Schema.Boolean>;
+    stream: Schema.optional<Schema.Boolean>;
+    stdin: Schema.optional<Schema.Boolean>;
+    stdout: Schema.optional<Schema.Boolean>;
+    stderr: Schema.optional<Schema.Boolean>;
+}>>, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof BadRequest | typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"wait", "POST", "/containers/:identifier/wait", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    condition: Schema.optional<Schema.String>;
+}>>, never, never, Schema.toCodecJson<typeof ContainerWaitResponse>, Schema.toCodecJson<typeof BadRequest | typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"delete", "DELETE", "/containers/:identifier", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    v: Schema.optional<Schema.Boolean>;
+    force: Schema.optional<Schema.Boolean>;
+    link: Schema.optional<Schema.Boolean>;
+}>>, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof BadRequest | typeof NotFound | typeof Conflict | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"archive", "GET", "/containers/:identifier/archive", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    path: Schema.String;
+}>>, never, never, HttpApiSchema.StreamUint8Array, Schema.toCodecJson<typeof BadRequest | typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"archiveInfo", "HEAD", "/containers/:identifier/archive", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    path: Schema.String;
+}>>, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof BadRequest | typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"putArchive", "PUT", "/containers/:identifier/archive", Schema.toCodecStringTree<Schema.Struct<{
+    identifier: Schema.brand<Schema.String, "ContainerId">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    path: Schema.String;
+    noOverwriteDirNonDir: Schema.optional<Schema.String>;
+    copyUIDGidentifier: Schema.optional<Schema.String>;
+}>>, Schema.toCodecJson<HttpApiSchema.StreamUint8Array>, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof BadRequest | typeof Forbidden | typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"prune", "POST", "/containers/prune", never, Schema.toCodecStringTree<Schema.Struct<{
+    filters: Schema.optional<Schema.fromJsonString<Schema.Struct<{
+        readonly until: Schema.optional<Schema.decodeTo<Schema.String, Schema.Tuple<readonly [Schema.String]>, never, never>>;
+        readonly label: Schema.optional<Schema.$Array<Schema.String>>;
+    }>>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly ContainersDeleted: Schema.NullOr<Schema.$Array<Schema.brand<Schema.String, "ContainerId">>>;
+    readonly SpaceReclaimed: Schema.BigIntFromString;
+}>>, Schema.toCodecJson<typeof InternalServerError>, never, never>, false>>;
+declare const Containers_base: Context.ServiceClass<Containers, "@the-moby-effect/endpoints/Containers", {
+    list: (options?: {
+        readonly all?: boolean | undefined;
+        readonly size?: boolean | undefined;
+        readonly limit?: number | undefined;
+        readonly filters?: {
+            readonly identifier?: readonly (string & import("effect/Brand").Brand<"ContainerId">)[] | undefined;
+            readonly volume?: string | undefined;
+            readonly name?: readonly string[] | undefined;
+            readonly status?: readonly ("running" | "paused" | "created" | "restarting" | "removing" | "exited" | "dead")[] | undefined;
+            readonly exited?: readonly number[] | undefined;
+            readonly network?: readonly string[] | undefined;
+            readonly label?: readonly string[] | undefined;
+            readonly ancestor?: readonly string[] | undefined;
+            readonly before?: readonly string[] | undefined;
+            readonly expose?: readonly string[] | undefined;
+            readonly health?: readonly ("none" | "starting" | "healthy" | "unhealthy")[] | undefined;
+            readonly "is-task"?: boolean | undefined;
+            readonly publish?: readonly string[] | undefined;
+            readonly since?: readonly string[] | undefined;
+        } | undefined;
+    } | undefined) => Effect.Effect<readonly ContainerSummary[], DockerError, never>;
+    create: (options: Omit<(typeof ContainerCreateRequest)["~type.make.in"], "HostConfig"> & {
+        readonly Name?: string | undefined;
+        readonly Platform?: string | undefined;
+        readonly HostConfig?: (typeof ContainerHostConfig)["~type.make.in"] | undefined;
+    }) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly Id: Schema.brand<Schema.String, "ContainerId">;
+        readonly Warnings: Schema.NullOr<Schema.$Array<Schema.String>>;
+    }, "Type">, DockerError, never>;
+    inspect: (identifier: ContainerIdentifier, options?: {
+        readonly size?: boolean | undefined;
+    }) => Effect.Effect<ContainerInspectResponse, DockerError, never>;
+    top: (identifier: ContainerIdentifier, options?: {
+        readonly ps_args?: string | undefined;
+    }) => Effect.Effect<ContainerTopResponse, DockerError, never>;
+    logs: (identifier: ContainerIdentifier, options?: {
+        readonly stdout?: boolean | undefined;
+        readonly stderr?: boolean | undefined;
+        readonly since?: number | undefined;
+        readonly until?: number | undefined;
+        readonly follow?: boolean | undefined;
+        readonly timestamps?: boolean | undefined;
+        readonly tail?: string | undefined;
+    }) => Stream.Stream<string, DockerError, never>;
+    changes: (identifier: ContainerIdentifier) => Effect.Effect<readonly ArchiveChange[] | null, DockerError, never>;
+    export: (identifier: ContainerIdentifier) => Stream.Stream<Uint8Array<ArrayBufferLike>, DockerError, never>;
+    stats: (identifier: ContainerIdentifier, options?: {
+        readonly stream?: boolean | undefined;
+        readonly "one-shot"?: boolean | undefined;
+    }) => Stream.Stream<ContainerStatsResponse, DockerError, never>;
+    resize: (identifier: ContainerIdentifier, options?: {
+        readonly h?: number | undefined;
+        readonly w?: number | undefined;
+    }) => Effect.Effect<void, DockerError, never>;
+    start: (identifier: ContainerIdentifier, options?: {
+        readonly detachKeys?: string | undefined;
+    }) => Effect.Effect<void, DockerError, never>;
+    stop: (identifier: ContainerIdentifier, options?: {
+        readonly signal?: string | undefined;
+        readonly t?: number | undefined;
+    }) => Effect.Effect<void, DockerError, never>;
+    restart: (identifier: ContainerIdentifier, options?: {
+        readonly signal?: string | undefined;
+        readonly t?: number | undefined;
+    }) => Effect.Effect<void, DockerError, never>;
+    kill: (identifier: ContainerIdentifier, options?: {
+        readonly signal?: string | undefined;
+    }) => Effect.Effect<void, DockerError, never>;
+    update: (identifier: ContainerIdentifier, config: (typeof ContainerConfig)["~type.make.in"]) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly Warnings: Schema.NullOr<Schema.$Array<Schema.String>>;
+    }, "Type">, DockerError, never>;
+    rename: (identifier: ContainerIdentifier, name: string) => Effect.Effect<void, DockerError, never>;
+    pause: (identifier: ContainerIdentifier) => Effect.Effect<void, DockerError, never>;
+    unpause: (identifier: ContainerIdentifier) => Effect.Effect<void, DockerError, never>;
+    attach: (identifier: ContainerIdentifier, options?: {
+        readonly stream?: boolean | undefined;
+        readonly stdout?: boolean | undefined;
+        readonly stderr?: boolean | undefined;
+        readonly stdin?: boolean | undefined;
+        readonly logs?: boolean | undefined;
+        readonly detachKeys?: string | undefined;
+    }) => Effect.Effect<import("../../MobyDemux.ts").MultiplexedSocket | import("../../MobyDemux.ts").RawSocket, DockerError, never>;
+    attachWebsocket: (identifier: ContainerIdentifier, options?: {
+        readonly stream?: boolean | undefined;
+        readonly stdout?: boolean | undefined;
+        readonly stderr?: boolean | undefined;
+        readonly stdin?: boolean | undefined;
+        readonly logs?: boolean | undefined;
+        readonly detachKeys?: string | undefined;
+    }) => Effect.Effect<import("../../MobyDemux.ts").RawSocket, DockerError, never>;
+    wait: (identifier: ContainerIdentifier, options?: {
+        readonly condition?: string | undefined;
+    }) => Effect.Effect<ContainerWaitResponse, DockerError, never>;
+    delete: (identifier: ContainerIdentifier, options?: {
+        readonly link?: boolean | undefined;
+        readonly force?: boolean | undefined;
+        readonly v?: boolean | undefined;
+    }) => Effect.Effect<void, DockerError, never>;
+    archive: (identifier: ContainerIdentifier, options: Schema.Struct.ReadonlySide<{
+        path: Schema.String;
+    }, "Type">) => Stream.Stream<Uint8Array<ArrayBufferLike>, DockerError, never>;
+    archiveInfo: (identifier: ContainerIdentifier, options: Schema.Struct.ReadonlySide<{
+        path: Schema.String;
+    }, "Type">) => Effect.Effect<unknown, DockerError, never>;
+    putArchive: <E, R>(identifier: ContainerIdentifier, stream: Stream.Stream<Uint8Array, E, R>, options: {
+        readonly path: string;
+        readonly noOverwriteDirNonDir?: string | undefined;
+        readonly copyUIDGidentifier?: string | undefined;
+    }) => Effect.Effect<void, DockerError, R>;
+    prune: (filters?: Schema.Schema.Type<typeof PruneFilters> | undefined) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly ContainersDeleted: Schema.NullOr<Schema.$Array<Schema.brand<Schema.String, "ContainerId">>>;
+        readonly SpaceReclaimed: Schema.BigIntFromString;
+    }, "Type">, DockerError, never>;
+}> & {
+    readonly make: Effect.Effect<{
         list: (options?: {
+            readonly all?: boolean | undefined;
             readonly size?: boolean | undefined;
             readonly limit?: number | undefined;
-            readonly all?: boolean | undefined;
             readonly filters?: {
                 readonly identifier?: readonly (string & import("effect/Brand").Brand<"ContainerId">)[] | undefined;
                 readonly volume?: string | undefined;
-                readonly exited?: readonly number[] | undefined;
                 readonly name?: readonly string[] | undefined;
-                readonly status?: readonly ("created" | "restarting" | "running" | "removing" | "paused" | "exited" | "dead")[] | undefined;
+                readonly status?: readonly ("running" | "paused" | "created" | "restarting" | "removing" | "exited" | "dead")[] | undefined;
+                readonly exited?: readonly number[] | undefined;
                 readonly network?: readonly string[] | undefined;
                 readonly label?: readonly string[] | undefined;
                 readonly ancestor?: readonly string[] | undefined;
@@ -202,14 +319,14 @@ declare const Containers_base: Effect.Service.Class<Containers, "@the-moby-effec
                 readonly since?: readonly string[] | undefined;
             } | undefined;
         } | undefined) => Effect.Effect<readonly ContainerSummary[], DockerError, never>;
-        create: (options: Omit<ConstructorParameters<typeof ContainerCreateRequest>[0], "HostConfig"> & {
+        create: (options: Omit<(typeof ContainerCreateRequest)["~type.make.in"], "HostConfig"> & {
             readonly Name?: string | undefined;
             readonly Platform?: string | undefined;
-            readonly HostConfig?: ConstructorParameters<typeof ContainerHostConfig>[0] | undefined;
-        }) => Effect.Effect<{
-            readonly Id: string & import("effect/Brand").Brand<"ContainerId">;
-            readonly Warnings: readonly string[] | null;
-        }, DockerError, never>;
+            readonly HostConfig?: (typeof ContainerHostConfig)["~type.make.in"] | undefined;
+        }) => Effect.Effect<Schema.Struct.ReadonlySide<{
+            readonly Id: Schema.brand<Schema.String, "ContainerId">;
+            readonly Warnings: Schema.NullOr<Schema.$Array<Schema.String>>;
+        }, "Type">, DockerError, never>;
         inspect: (identifier: ContainerIdentifier, options?: {
             readonly size?: boolean | undefined;
         }) => Effect.Effect<ContainerInspectResponse, DockerError, never>;
@@ -249,9 +366,9 @@ declare const Containers_base: Effect.Service.Class<Containers, "@the-moby-effec
         kill: (identifier: ContainerIdentifier, options?: {
             readonly signal?: string | undefined;
         }) => Effect.Effect<void, DockerError, never>;
-        update: (identifier: ContainerIdentifier, config: ContainerConfig) => Effect.Effect<{
-            readonly Warnings: readonly string[] | null;
-        }, DockerError, never>;
+        update: (identifier: ContainerIdentifier, config: (typeof ContainerConfig)["~type.make.in"]) => Effect.Effect<Schema.Struct.ReadonlySide<{
+            readonly Warnings: Schema.NullOr<Schema.$Array<Schema.String>>;
+        }, "Type">, DockerError, never>;
         rename: (identifier: ContainerIdentifier, name: string) => Effect.Effect<void, DockerError, never>;
         pause: (identifier: ContainerIdentifier) => Effect.Effect<void, DockerError, never>;
         unpause: (identifier: ContainerIdentifier) => Effect.Effect<void, DockerError, never>;
@@ -279,23 +396,23 @@ declare const Containers_base: Effect.Service.Class<Containers, "@the-moby-effec
             readonly force?: boolean | undefined;
             readonly v?: boolean | undefined;
         }) => Effect.Effect<void, DockerError, never>;
-        archive: (identifier: ContainerIdentifier, options: {
-            readonly path: string;
-        }) => Stream.Stream<Uint8Array<ArrayBufferLike>, DockerError, never>;
-        archiveInfo: (identifier: ContainerIdentifier, options: {
-            readonly path: string;
-        }) => Effect.Effect<unknown, DockerError, never>;
+        archive: (identifier: ContainerIdentifier, options: Schema.Struct.ReadonlySide<{
+            path: Schema.String;
+        }, "Type">) => Stream.Stream<Uint8Array<ArrayBufferLike>, DockerError, never>;
+        archiveInfo: (identifier: ContainerIdentifier, options: Schema.Struct.ReadonlySide<{
+            path: Schema.String;
+        }, "Type">) => Effect.Effect<unknown, DockerError, never>;
         putArchive: <E, R>(identifier: ContainerIdentifier, stream: Stream.Stream<Uint8Array, E, R>, options: {
             readonly path: string;
             readonly noOverwriteDirNonDir?: string | undefined;
             readonly copyUIDGidentifier?: string | undefined;
         }) => Effect.Effect<void, DockerError, R>;
-        prune: (filters?: Schema.Schema.Type<PruneFilters> | undefined) => Effect.Effect<{
-            readonly ContainersDeleted: readonly (string & import("effect/Brand").Brand<"ContainerId">)[] | null;
-            readonly SpaceReclaimed: bigint & import("effect/Brand").Brand<"I64">;
-        }, DockerError, never>;
+        prune: (filters?: Schema.Schema.Type<typeof PruneFilters> | undefined) => Effect.Effect<Schema.Struct.ReadonlySide<{
+            readonly ContainersDeleted: Schema.NullOr<Schema.$Array<Schema.brand<Schema.String, "ContainerId">>>;
+            readonly SpaceReclaimed: Schema.BigIntFromString;
+        }, "Type">, DockerError, never>;
     }, never, HttpClient.HttpClient | Socket.WebSocketConstructor>;
-}>;
+};
 /**
  * @since 1.0.0
  * @category Services
@@ -308,12 +425,12 @@ export declare class Containers extends Containers_base {
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Container
  */
-export declare const ContainersLayerLocalSocket: Layer.Layer<Containers, never, HttpClient.HttpClient | Socket.WebSocketConstructor>;
+export declare const ContainersLayer: Layer.Layer<Containers, never, HttpClient.HttpClient | Socket.WebSocketConstructor>;
 /**
  * @since 1.0.0
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Container
  */
-export declare const ContainersLayer: Layer.Layer<Containers, never, HttpClient.HttpClient | Socket.WebSocketConstructor>;
+export declare const ContainersLayerLocalSocket: Layer.Layer<Containers, never, HttpClient.HttpClient | Socket.WebSocketConstructor>;
 export {};
 //# sourceMappingURL=containers.d.ts.map