the-moby-effect 1.51.6 → 1.54.1

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

@@ -1,17 +1,22 @@
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpClient } from "@effect/platform";
-import { Effect, Schema, Stream, type Layer } from "effect";
-import { SwarmService, SwarmServiceSpec } from "../generated/index.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 { SwarmService, SwarmServiceSpec } from "../generated/index.ts";
 import { DockerError } from "./circular.ts";
-import { BadRequest, Conflict, Forbidden, InternalServerError, NotFound } from "./httpApiHacks.js";
-import { NodeNotPartOfSwarm } from "./swarm.js";
-declare const ListFilters_base: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
-    id: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    label: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    mode: Schema.optional<Schema.Array$<Schema.Literal<["replicated", "global"]>>>;
-}>>;
+import { BadRequest, Conflict, Forbidden, InternalServerError, NotFound, ServiceUnavailable } from "./errors.ts";
 /** @since 1.0.0 */
-export declare class ListFilters extends ListFilters_base {
-}
+export declare const ListFilters: Schema.fromJsonString<Schema.Struct<{
+    readonly id: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly label: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly mode: Schema.optional<Schema.$Array<Schema.Literals<readonly ["replicated", "global"]>>>;
+}>>;
 /**
  * Services are the definitions of tasks to run on a swarm. Swarm mode must be
  * enabled for these endpoints to work.
@@ -20,69 +25,89 @@ export declare class ListFilters extends ListFilters_base {
  * @category HttpApi
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
  */
-export declare const ServicesApi: HttpApi.HttpApi<"ServicesApi", HttpApiGroup.HttpApiGroup<"services", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", never, {
-    readonly status?: boolean | undefined;
-    readonly filters?: {
-        readonly mode?: readonly ("global" | "replicated")[] | undefined;
-        readonly id?: readonly string[] | undefined;
-        readonly label?: readonly string[] | undefined;
-    } | undefined;
-}, never, never, readonly SwarmService[], NodeNotPartOfSwarm, never, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", never, never, SwarmServiceSpec, {
-    readonly "X-Registry-Auth"?: string | undefined;
-}, {
-    readonly ID: string & import("effect/Brand").Brand<"ServiceId">;
-    readonly Warnings?: readonly string[] | undefined;
-}, BadRequest | Forbidden | Conflict | NodeNotPartOfSwarm, never, never> | HttpApiEndpoint.HttpApiEndpoint<"delete", "DELETE", {
-    readonly id: string;
-}, never, never, never, void, NotFound | NodeNotPartOfSwarm, never, never> | HttpApiEndpoint.HttpApiEndpoint<"inspect", "GET", {
-    readonly id: string;
-}, {
-    readonly insertDefaults?: boolean | undefined;
-}, never, never, SwarmService, NotFound | NodeNotPartOfSwarm, never, never> | HttpApiEndpoint.HttpApiEndpoint<"update", "POST", {
-    readonly id: string;
-}, {
-    readonly version: number;
-    readonly rollback?: string | undefined;
-    readonly registryAuthFrom?: string | undefined;
-}, SwarmServiceSpec, {
-    readonly "X-Registry-Auth"?: string | undefined;
-}, {
-    readonly Warnings?: readonly string[] | undefined;
-}, BadRequest | NotFound | NodeNotPartOfSwarm, never, never> | HttpApiEndpoint.HttpApiEndpoint<"logs", "GET", {
-    readonly id: string;
-}, {
-    readonly stdout?: boolean | undefined;
-    readonly stderr?: boolean | undefined;
-    readonly since?: number | undefined;
-    readonly follow?: boolean | undefined;
-    readonly timestamps?: boolean | undefined;
-    readonly tail?: string | undefined;
-    readonly details?: boolean | undefined;
-}, never, never, void, NotFound | NodeNotPartOfSwarm, never, never>, InternalServerError, never, false>, import("@effect/platform/HttpApiError").HttpApiDecodeError, never>;
-declare const Services_base: Effect.Service.Class<Services, "@the-moby-effect/endpoints/Services", {
-    readonly accessors: false;
-    readonly dependencies: readonly [Layer.Layer<HttpClient.HttpClient, never, HttpClient.HttpClient>];
-    readonly effect: Effect.Effect<{
+export declare const ServicesApi: HttpApi.HttpApi<"ServicesApi", HttpApiGroup.HttpApiGroup<"services", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/services/", never, Schema.toCodecStringTree<Schema.Struct<{
+    filters: Schema.optional<Schema.fromJsonString<Schema.Struct<{
+        readonly id: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly label: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly mode: Schema.optional<Schema.$Array<Schema.Literals<readonly ["replicated", "global"]>>>;
+    }>>>;
+    status: Schema.optional<Schema.Boolean>;
+}>>, never, never, Schema.toCodecJson<Schema.$Array<typeof SwarmService>>, Schema.toCodecJson<typeof InternalServerError | typeof ServiceUnavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", "/services/create", never, never, Schema.toCodecJson<typeof SwarmServiceSpec>, Schema.toCodecStringTree<Schema.Struct<{
+    "X-Registry-Auth": Schema.optional<Schema.String>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly ID: Schema.brand<Schema.String, "ServiceId">;
+    readonly Warnings: Schema.optional<Schema.$Array<Schema.String>>;
+}>>, Schema.toCodecJson<typeof BadRequest | typeof Forbidden | typeof Conflict | typeof InternalServerError | typeof ServiceUnavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"delete", "DELETE", "/services/:id", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.String;
+}>>, never, never, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError | typeof ServiceUnavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"inspect", "GET", "/services/:id", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    insertDefaults: Schema.optional<Schema.Boolean>;
+}>>, never, never, Schema.toCodecJson<typeof SwarmService>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError | typeof ServiceUnavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"update", "POST", "/services/:id/update", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    version: Schema.Number;
+    rollback: Schema.optional<Schema.String>;
+    registryAuthFrom: Schema.optional<Schema.String>;
+}>>, Schema.toCodecJson<typeof SwarmServiceSpec>, Schema.toCodecStringTree<Schema.Struct<{
+    "X-Registry-Auth": Schema.optional<Schema.String>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly Warnings: Schema.optional<Schema.$Array<Schema.String>>;
+}>>, Schema.toCodecJson<typeof BadRequest | typeof NotFound | typeof InternalServerError | typeof ServiceUnavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"logs", "GET", "/services/:id/logs", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    details: Schema.optional<Schema.Boolean>;
+    follow: Schema.optional<Schema.Boolean>;
+    stdout: Schema.optional<Schema.Boolean>;
+    stderr: Schema.optional<Schema.Boolean>;
+    since: Schema.optional<Schema.Number>;
+    timestamps: Schema.optional<Schema.Boolean>;
+    tail: Schema.optional<Schema.String>;
+}>>, never, never, HttpApiSchema.StreamUint8Array, Schema.toCodecJson<typeof NotFound | typeof InternalServerError | typeof ServiceUnavailable>, never, never>, false>>;
+declare const Services_base: Context.ServiceClass<Services, "@the-moby-effect/endpoints/Services", {
+    list: (options?: {
+        readonly status?: boolean | undefined;
+        readonly filters?: {
+            readonly mode?: readonly ("replicated" | "global")[] | undefined;
+            readonly id?: readonly string[] | undefined;
+            readonly label?: readonly string[] | undefined;
+        } | undefined;
+    }) => Effect.Effect<readonly SwarmService[], DockerError, never>;
+    create: (payload: (typeof SwarmServiceSpec)["~type.make.in"]) => Effect.Effect<{
+        readonly ID: string & import("effect/Brand").Brand<"ServiceId">;
+        readonly Warnings?: readonly string[] | undefined;
+    }, DockerError, never>;
+    delete: (id: string) => Effect.Effect<void, DockerError, never>;
+    inspect: (id: string, options?: {
+        readonly insertDefaults?: boolean | undefined;
+    }) => Effect.Effect<SwarmService, DockerError, never>;
+    update: (id: string, options: {
+        readonly version: number;
+        readonly rollback?: string | undefined;
+        readonly registryAuthFrom?: string | undefined;
+    }, payload: (typeof SwarmServiceSpec)["~type.make.in"]) => Effect.Effect<{
+        readonly Warnings?: readonly string[] | undefined;
+    }, DockerError, never>;
+    logs: (id: string, options?: {
+        readonly stdout?: boolean | undefined;
+        readonly stderr?: boolean | undefined;
+        readonly since?: number | undefined;
+        readonly follow?: boolean | undefined;
+        readonly timestamps?: boolean | undefined;
+        readonly tail?: string | undefined;
+        readonly details?: boolean | undefined;
+    }) => Effect.Effect<Stream.Stream<string, DockerError, never>, DockerError, never>;
+}> & {
+    readonly make: Effect.Effect<{
         list: (options?: {
             readonly status?: boolean | undefined;
             readonly filters?: {
-                readonly mode?: readonly ("global" | "replicated")[] | undefined;
+                readonly mode?: readonly ("replicated" | "global")[] | undefined;
                 readonly id?: readonly string[] | undefined;
                 readonly label?: readonly string[] | undefined;
             } | undefined;
         }) => Effect.Effect<readonly SwarmService[], DockerError, never>;
-        create: (props: {
-            readonly Labels: {
-                readonly [x: string]: string;
-            } | null;
-            readonly Name?: string | undefined;
-            readonly Mode?: import("../generated/SwarmServiceMode.generated.ts").SwarmServiceMode | undefined;
-            readonly Networks?: readonly (import("../generated/SwarmNetworkAttachmentConfig.generated.ts").SwarmNetworkAttachmentConfig | null)[] | undefined;
-            readonly TaskTemplate?: import("../generated/SwarmTaskSpec.generated.ts").SwarmTaskSpec | undefined;
-            readonly UpdateConfig?: import("../generated/SwarmUpdateConfig.generated.ts").SwarmUpdateConfig | undefined;
-            readonly RollbackConfig?: import("../generated/SwarmUpdateConfig.generated.ts").SwarmUpdateConfig | undefined;
-            readonly EndpointSpec?: import("../generated/SwarmEndpointSpec.generated.ts").SwarmEndpointSpec | undefined;
-        }, options?: Schema.MakeOptions | undefined) => Effect.Effect<{
+        create: (payload: (typeof SwarmServiceSpec)["~type.make.in"]) => Effect.Effect<{
             readonly ID: string & import("effect/Brand").Brand<"ServiceId">;
             readonly Warnings?: readonly string[] | undefined;
         }, DockerError, never>;
@@ -94,18 +119,7 @@ declare const Services_base: Effect.Service.Class<Services, "@the-moby-effect/en
             readonly version: number;
             readonly rollback?: string | undefined;
             readonly registryAuthFrom?: string | undefined;
-        }, props: {
-            readonly Labels: {
-                readonly [x: string]: string;
-            } | null;
-            readonly Name?: string | undefined;
-            readonly Mode?: import("../generated/SwarmServiceMode.generated.ts").SwarmServiceMode | undefined;
-            readonly Networks?: readonly (import("../generated/SwarmNetworkAttachmentConfig.generated.ts").SwarmNetworkAttachmentConfig | null)[] | undefined;
-            readonly TaskTemplate?: import("../generated/SwarmTaskSpec.generated.ts").SwarmTaskSpec | undefined;
-            readonly UpdateConfig?: import("../generated/SwarmUpdateConfig.generated.ts").SwarmUpdateConfig | undefined;
-            readonly RollbackConfig?: import("../generated/SwarmUpdateConfig.generated.ts").SwarmUpdateConfig | undefined;
-            readonly EndpointSpec?: import("../generated/SwarmEndpointSpec.generated.ts").SwarmEndpointSpec | undefined;
-        }, options?: Schema.MakeOptions | undefined) => Effect.Effect<{
+        }, payload: (typeof SwarmServiceSpec)["~type.make.in"]) => Effect.Effect<{
             readonly Warnings?: readonly string[] | undefined;
         }, DockerError, never>;
         logs: (id: string, options?: {
@@ -116,9 +130,9 @@ declare const Services_base: Effect.Service.Class<Services, "@the-moby-effect/en
             readonly timestamps?: boolean | undefined;
             readonly tail?: string | undefined;
             readonly details?: boolean | undefined;
-        }) => Stream.Stream<string, DockerError, never>;
+        }) => Effect.Effect<Stream.Stream<string, DockerError, never>, DockerError, never>;
     }, never, HttpClient.HttpClient>;
-}>;
+};
 /**
  * Services are the definitions of tasks to run on a swarm. Swarm mode must be
  * enabled for these endpoints to work.
@@ -137,7 +151,7 @@ export declare class Services extends Services_base {
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
  */
-export declare const ServicesLayerLocalSocket: Layer.Layer<Services, never, HttpClient.HttpClient>;
+export declare const ServicesLayer: Layer.Layer<Services, never, HttpClient.HttpClient>;
 /**
  * Services are the definitions of tasks to run on a swarm. Swarm mode must be
  * enabled for these endpoints to work.
@@ -146,6 +160,6 @@ export declare const ServicesLayerLocalSocket: Layer.Layer<Services, never, Http
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
  */
-export declare const ServicesLayer: Layer.Layer<Services, never, HttpClient.HttpClient>;
+export declare const ServicesLayerLocalSocket: Layer.Layer<Services, never, HttpClient.HttpClient>;
 export {};
 //# sourceMappingURL=services.d.ts.map

package/dist/internal/endpoints/services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../src/internal/endpoints/services.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAiB,eAAe,EAAE,YAAY,EAAiB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACpH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAC;AAI5D,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGvE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EACH,UAAU,EACV,QAAQ,EACR,SAAS,EAET,mBAAmB,EACnB,QAAQ,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;;;;;;AAEhD,mBAAmB;AACnB,qBAAa,WAAY,SAAQ,gBAMhC;CAAG;AA8FJ;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2KAAiD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4C7C,MAAM;sBACL,MAAM;;;qBAGpB,MAAM;;;;;;;;;;;;;;;;;;mBAaK,MAAM;;;;;;;;;;;AA3DjC;;;;;;;GAOG;AACH,qBAAa,QAAS,SAAQ,aAuE5B;CAAG;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAoB,CAAC;AAE9G;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAuC,CAAC"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../src/internal/endpoints/services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,UAAU,MAAM,iCAAiC,CAAC;AAC9D,OAAO,KAAK,OAAO,MAAM,iCAAiC,CAAC;AAE3D,OAAO,KAAK,eAAe,MAAM,yCAAyC,CAAC;AAC3E,OAAO,KAAK,YAAY,MAAM,sCAAsC,CAAC;AACrE,OAAO,KAAK,aAAa,MAAM,uCAAuC,CAAC;AAIvE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGvE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,mBAAmB,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjH,mBAAmB;AACnB,eAAO,MAAM,WAAW;;;;GAMvB,CAAC;AA0GF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uKAAiD,CAAC;;;;;;;;;;sBA4BxC,CAAC,OAAO,gBAAgB,EAAE,eAAe,CAAC;;;;iBAU/C,MAAM;kBAEL,MAAM;;;iBAEP,MAAM;;;;gBAAuC,CAAC,OAAO,gBAAgB,EAAE,eAAe,CAAC;;;eAYzF,MAAM;;;;;;;;;;;;;;;;;;;0BA1BC,CAAC,OAAO,gBAAgB,EAAE,eAAe,CAAC;;;;qBAU/C,MAAM;sBAEL,MAAM;;;qBAEP,MAAM;;;;oBAAuC,CAAC,OAAO,gBAAgB,EAAE,eAAe,CAAC;;;mBAYzF,MAAM;;;;;;;;;;;AApDjC;;;;;;;GAOG;AACH,qBAAa,QAAS,SAAQ,aA+D5B;CAAG;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAyC,CAAC;AAExH;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAQxF,CAAC"}

package/dist/internal/endpoints/services.js

@@ -1,89 +1,139 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
-import { Effect, Schema, Stream } from "effect";
+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 HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+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 { MobyConnectionOptions } from "../../MobyConnection.js";
 import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
 import { SwarmService, SwarmServiceSpec } from "../generated/index.js";
 import { ServiceIdentifier } from "../schemas/id.js";
 import { WithRegistryAuthHeader } from "./auth.js";
 import { DockerError } from "./circular.js";
-import { BadRequest, Conflict, Forbidden, HttpApiStreamingResponse, InternalServerError, NotFound } from "./httpApiHacks.js";
-import { NodeNotPartOfSwarm } from "./swarm.js";
+import { BadRequest, Conflict, Forbidden, InternalServerError, NotFound, ServiceUnavailable } from "./errors.js";
 /** @since 1.0.0 */
-export class ListFilters extends /*#__PURE__*/Schema.parseJson(/*#__PURE__*/Schema.Struct({
+export const ListFilters = /*#__PURE__*/Schema.fromJsonString(/*#__PURE__*/Schema.Struct({
   id: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
   label: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
-  mode: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Literal("replicated", "global")))
-})) {}
+  mode: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Literals(["replicated", "global"])))
+}));
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceList */
-const listServicesEndpoint = /*#__PURE__*/HttpApiEndpoint.get("list", "/").setUrlParams(Schema.Struct({
-  filters: Schema.optional(ListFilters),
-  status: Schema.optional(Schema.BooleanFromString)
-})).addSuccess(Schema.Array(SwarmService), {
-  status: 200
-}) // 200 OK
-.addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const listServicesEndpoint = /*#__PURE__*/HttpApiEndpoint.get("list", "/", {
+  query: {
+    filters: /*#__PURE__*/Schema.optional(ListFilters),
+    status: /*#__PURE__*/Schema.optional(Schema.Boolean)
+  },
+  success: /*#__PURE__*/Schema.Array(SwarmService),
+  // 200 OK
+  error: [ServiceUnavailable,
+  // 503 Node is not part of a swarm
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceCreate */
-const createServiceEndpoint = /*#__PURE__*/HttpApiEndpoint.post("create", "/create").setPayload(SwarmServiceSpec).setHeaders(Schema.Struct({
-  "X-Registry-Auth": Schema.optional(Schema.String)
-})).addSuccess(Schema.Struct({
-  ID: ServiceIdentifier,
-  Warnings: Schema.optional(Schema.Array(Schema.String))
-}), {
-  status: 201
-}) // 201 Created
-.addError(BadRequest) // 400 Bad request
-.addError(Forbidden) // 403 network is not eligible for services
-.addError(Conflict) // 409 name conflicts with an existing object
-.addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const createServiceEndpoint = /*#__PURE__*/HttpApiEndpoint.post("create", "/create", {
+  payload: SwarmServiceSpec,
+  headers: {
+    "X-Registry-Auth": /*#__PURE__*/Schema.optional(Schema.String)
+  },
+  success: /*#__PURE__*/Schema.Struct({
+    ID: ServiceIdentifier,
+    Warnings: Schema.optional(Schema.Array(Schema.String))
+  }).pipe(/*#__PURE__*/HttpApiSchema.status(201)),
+  // 201 Created
+  error: [BadRequest,
+  // 400 Bad request
+  Forbidden,
+  // 403 network is not eligible for services
+  Conflict,
+  // 409 name conflicts with an existing object
+  ServiceUnavailable,
+  // 503 Node is not part of a swarm
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceDelete */
-const deleteServiceEndpoint = /*#__PURE__*/HttpApiEndpoint.del("delete", "/:id").setPath(Schema.Struct({
-  id: Schema.String
-})).addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(NotFound) // 404 No such service
-.addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const deleteServiceEndpoint = /*#__PURE__*/HttpApiEndpoint.delete("delete", "/:id", {
+  params: {
+    id: Schema.String
+  },
+  success: /*#__PURE__*/HttpApiSchema.Empty(200),
+  // 200 OK
+  error: [NotFound,
+  // 404 No such service
+  ServiceUnavailable,
+  // 503 Node is not part of a swarm
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceInspect */
-const inspectServiceEndpoint = /*#__PURE__*/HttpApiEndpoint.get("inspect", "/:id").setPath(Schema.Struct({
-  id: Schema.String
-})).setUrlParams(Schema.Struct({
-  insertDefaults: Schema.optional(Schema.BooleanFromString)
-})).addSuccess(SwarmService, {
-  status: 200
-}) // 200 OK
-.addError(NotFound) // 404 No such service
-.addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const inspectServiceEndpoint = /*#__PURE__*/HttpApiEndpoint.get("inspect", "/:id", {
+  params: {
+    id: Schema.String
+  },
+  query: {
+    insertDefaults: /*#__PURE__*/Schema.optional(Schema.Boolean)
+  },
+  success: SwarmService,
+  // 200 OK
+  error: [NotFound,
+  // 404 No such service
+  ServiceUnavailable,
+  // 503 Node is not part of a swarm
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceUpdate */
-const updateServiceEndpoint = /*#__PURE__*/HttpApiEndpoint.post("update", "/:id/update").setPath(Schema.Struct({
-  id: Schema.String
-})).setUrlParams(Schema.Struct({
-  version: Schema.NumberFromString,
-  rollback: Schema.optional(Schema.String),
-  registryAuthFrom: Schema.optional(Schema.String)
-})).setHeaders(Schema.Struct({
-  "X-Registry-Auth": Schema.optional(Schema.String)
-})).setPayload(SwarmServiceSpec).addSuccess(Schema.Struct({
-  Warnings: Schema.optional(Schema.Array(Schema.String))
-}), {
-  status: 200
-}) // 200 OK
-.addError(BadRequest) // 400 Bad request
-.addError(NotFound) // 404 No such service
-.addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const updateServiceEndpoint = /*#__PURE__*/HttpApiEndpoint.post("update", "/:id/update", {
+  params: {
+    id: Schema.String
+  },
+  query: {
+    version: Schema.Number,
+    rollback: /*#__PURE__*/Schema.optional(Schema.String),
+    registryAuthFrom: /*#__PURE__*/Schema.optional(Schema.String)
+  },
+  headers: {
+    "X-Registry-Auth": /*#__PURE__*/Schema.optional(Schema.String)
+  },
+  payload: SwarmServiceSpec,
+  success: /*#__PURE__*/Schema.Struct({
+    Warnings: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String))
+  }),
+  // 200 OK
+  error: [BadRequest,
+  // 400 Bad request
+  NotFound,
+  // 404 No such service
+  ServiceUnavailable,
+  // 503 Node is not part of a swarm
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceLogs */
-const logsServiceEndpoint = /*#__PURE__*/HttpApiEndpoint.get("logs", "/:id/logs").setPath(Schema.Struct({
-  id: Schema.String
-})).setUrlParams(Schema.Struct({
-  details: Schema.optional(Schema.BooleanFromString),
-  follow: Schema.optional(Schema.BooleanFromString),
-  stdout: Schema.optional(Schema.BooleanFromString),
-  stderr: Schema.optional(Schema.BooleanFromString),
-  since: Schema.optional(Schema.NumberFromString),
-  timestamps: Schema.optional(Schema.BooleanFromString),
-  tail: Schema.optional(Schema.String)
-})).addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(NotFound) // 404 No such service
-.addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const logsServiceEndpoint = /*#__PURE__*/HttpApiEndpoint.get("logs", "/:id/logs", {
+  params: {
+    id: Schema.String
+  },
+  query: {
+    details: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    follow: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stdout: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    stderr: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    since: /*#__PURE__*/Schema.optional(Schema.Number),
+    timestamps: /*#__PURE__*/Schema.optional(Schema.Boolean),
+    tail: /*#__PURE__*/Schema.optional(Schema.String)
+  },
+  success: /*#__PURE__*/HttpApiSchema.StreamUint8Array(),
+  // 200 OK (streaming response)
+  error: [NotFound,
+  // 404 No such service
+  ServiceUnavailable,
+  // 503 Node is not part of a swarm
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service */
-const ServicesGroup = /*#__PURE__*/HttpApiGroup.make("services").add(listServicesEndpoint).add(createServiceEndpoint).add(deleteServiceEndpoint).add(inspectServiceEndpoint).add(updateServiceEndpoint).add(logsServiceEndpoint).addError(InternalServerError).prefix("/services");
+const ServicesGroup = /*#__PURE__*/HttpApiGroup.make("services").add(listServicesEndpoint, createServiceEndpoint, deleteServiceEndpoint, inspectServiceEndpoint, updateServiceEndpoint, logsServiceEndpoint).prefix("/services");
 /**
  * Services are the definitions of tasks to run on a swarm. Swarm mode must be
  * enabled for these endpoints to work.
@@ -101,58 +151,54 @@ export const ServicesApi = /*#__PURE__*/HttpApi.make("ServicesApi").add(Services
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
  */
-export class Services extends /*#__PURE__*/Effect.Service()("@the-moby-effect/endpoints/Services", {
-  accessors: false,
-  dependencies: [/*#__PURE__*/makeAgnosticHttpClientLayer(/*#__PURE__*/MobyConnectionOptions.socket({
-    socketPath: "/var/run/docker.sock"
-  }))],
-  effect: /*#__PURE__*/Effect.gen(function* () {
+export class Services extends /*#__PURE__*/Context.Service()("@the-moby-effect/endpoints/Services", {
+  make: /*#__PURE__*/Effect.gen(function* () {
     const httpClient = yield* Effect.map(HttpClient.HttpClient, WithRegistryAuthHeader(createServiceEndpoint, updateServiceEndpoint));
     const ServicesError = DockerError.WrapForModule("services");
     const client = yield* HttpApiClient.group(ServicesApi, {
       group: "services",
       httpClient
     });
-    const list_ = options => Effect.mapError(client.list({
-      urlParams: {
+    const list_ = options => client.list({
+      query: {
         ...options
       }
-    }), ServicesError("list"));
-    const create_ = (...payload) => Effect.mapError(client.create({
+    }).pipe(Effect.mapError(ServicesError("list")));
+    const create_ = payload => SwarmServiceSpec.makeEffect(payload).pipe(Effect.flatMap(payload => client.create({
       headers: {},
-      payload: SwarmServiceSpec.make(...payload)
-    }), ServicesError("create"));
-    const delete_ = id => Effect.mapError(client.delete({
-      path: {
+      payload
+    })), Effect.mapError(ServicesError("create")));
+    const delete_ = id => client.delete({
+      params: {
         id
       }
-    }), ServicesError("delete"));
-    const inspect_ = (id, options) => Effect.mapError(client.inspect({
-      path: {
+    }).pipe(Effect.mapError(ServicesError("delete")));
+    const inspect_ = (id, options) => client.inspect({
+      params: {
         id
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), ServicesError("inspect"));
-    const update_ = (id, options, ...payload) => Effect.mapError(client.update({
+    }).pipe(Effect.mapError(ServicesError("inspect")));
+    const update_ = (id, options, payload) => SwarmServiceSpec.makeEffect(payload).pipe(Effect.flatMap(payload => client.update({
       headers: {},
-      path: {
+      params: {
         id
       },
-      urlParams: {
+      query: {
         ...options
       },
-      payload: SwarmServiceSpec.make(...payload)
-    }), ServicesError("update"));
-    const logs_ = (id, options) => HttpApiStreamingResponse(ServicesApi, "services", "logs", httpClient)({
-      path: {
+      payload
+    })), Effect.mapError(ServicesError("update")));
+    const logs_ = (id, options) => client.logs({
+      params: {
         id
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }).pipe(Stream.decodeText()).pipe(Stream.splitLines).pipe(Stream.mapError(ServicesError("logs")));
+    }).pipe(Effect.map(Stream.decodeText()), Effect.map(Stream.splitLines), Effect.map(Stream.mapError(ServicesError("logs"))), Effect.mapError(ServicesError("logs")));
     return {
       list: list_,
       create: create_,
@@ -171,7 +217,7 @@ export class Services extends /*#__PURE__*/Effect.Service()("@the-moby-effect/en
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
  */
-export const ServicesLayerLocalSocket = Services.Default;
+export const ServicesLayer = /*#__PURE__*/Layer.effect(Services, Services.make);
 /**
  * Services are the definitions of tasks to run on a swarm. Swarm mode must be
  * enabled for these endpoints to work.
@@ -180,5 +226,7 @@ export const ServicesLayerLocalSocket = Services.Default;
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
  */
-export const ServicesLayer = Services.DefaultWithoutDependencies;
+export const ServicesLayerLocalSocket = /*#__PURE__*/ServicesLayer.pipe(/*#__PURE__*/Layer.provide(/*#__PURE__*/makeAgnosticHttpClientLayer(/*#__PURE__*/MobyConnectionOptions.socket({
+  socketPath: "/var/run/docker.sock"
+}))));
 //# sourceMappingURL=services.js.map