the-moby-effect 1.51.6 → 1.54.1

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

@@ -1,79 +1,274 @@
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpClient } from "@effect/platform";
-import { Effect, Schema, type Layer } from "effect";
-import { VolumeClusterVolumeSpec as ClusterVolumeSpec, VolumeVolume as Volume, VolumeCreateOptions } 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 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 { VolumeClusterVolumeSpec as ClusterVolumeSpec, VolumeVolume as Volume, VolumeCreateOptions } from "../generated/index.ts";
 import { DockerError } from "./circular.ts";
-import { BadRequest, Conflict, InternalServerError, NotFound } from "./httpApiHacks.ts";
-import { NodeNotPartOfSwarm } from "./swarm.js";
-declare const ListFilters_base: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
-    name: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    driver: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    label: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    dangling: Schema.optional<Schema.Array$<Schema.Literal<["true", "false", "1", "0"]>>>;
-}>>;
+import { BadRequest, Conflict, InternalServerError, NotFound, ServiceUnavailable } 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<{
-    label: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    all: Schema.optional<Schema.Array$<Schema.Literal<["true", "false", "1", "0"]>>>;
+export declare const ListFilters: Schema.fromJsonString<Schema.Struct<{
+    readonly name: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly driver: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly label: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly dangling: Schema.optional<Schema.$Array<Schema.Literals<readonly ["true", "false", "1", "0"]>>>;
 }>>;
 /** @since 1.0.0 */
-export declare class PruneFilters extends PruneFilters_base {
-}
+export declare const PruneFilters: Schema.fromJsonString<Schema.Struct<{
+    readonly label: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly all: Schema.optional<Schema.$Array<Schema.Literals<readonly ["true", "false", "1", "0"]>>>;
+}>>;
 /**
  * @since 1.0.0
  * @category HttpApi
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume
  */
-export declare const VolumesApi: HttpApi.HttpApi<"VolumesApi", HttpApiGroup.HttpApiGroup<"volumes", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", never, {
-    readonly filters?: {
-        readonly name?: readonly string[] | undefined;
-        readonly label?: readonly string[] | undefined;
-        readonly dangling?: readonly ("0" | "1" | "true" | "false")[] | undefined;
-        readonly driver?: readonly string[] | undefined;
-    } | undefined;
-}, never, never, {
-    readonly Volumes: readonly Volume[];
-    readonly Warnings: readonly string[] | null;
-}, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", never, never, VolumeCreateOptions, never, Volume, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"inspect", "GET", {
-    readonly name: string;
-}, never, never, never, Volume, NotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"delete", "DELETE", {
-    readonly name: string;
-}, {
-    readonly force?: boolean | undefined;
-}, never, never, void, NotFound | Conflict, never, never> | HttpApiEndpoint.HttpApiEndpoint<"update", "PUT", {
-    readonly name: string;
-}, {
-    readonly version: number;
-}, ClusterVolumeSpec, never, void, BadRequest | NotFound | NodeNotPartOfSwarm, never, never> | HttpApiEndpoint.HttpApiEndpoint<"prune", "POST", never, {
-    readonly filters?: {
-        readonly all?: readonly ("0" | "1" | "true" | "false")[] | undefined;
-        readonly label?: readonly string[] | undefined;
-    } | undefined;
-}, never, never, {
-    readonly SpaceReclaimed: bigint & import("effect/Brand").Brand<"I64">;
-    readonly VolumesDeleted?: readonly (string & import("effect/Brand").Brand<"VolumeId">)[] | undefined;
-}, never, never, never>, InternalServerError, never, false>, import("@effect/platform/HttpApiError").HttpApiDecodeError, never>;
-declare const Volumes_base: Effect.Service.Class<Volumes, "@the-moby-effect/endpoints/Volumes", {
-    readonly accessors: false;
-    readonly dependencies: readonly [Layer.Layer<HttpClient.HttpClient, never, HttpClient.HttpClient>];
-    readonly effect: Effect.Effect<{
-        list: (filters?: Schema.Schema.Type<ListFilters>) => Effect.Effect<{
-            readonly Volumes: readonly Volume[];
-            readonly Warnings: readonly string[] | null;
-        }, DockerError, never>;
-        create: (options: VolumeCreateOptions) => Effect.Effect<Volume, DockerError, never>;
+export declare const VolumesApi: HttpApi.HttpApi<"VolumesApi", HttpApiGroup.HttpApiGroup<"volumes", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/volumes/", never, Schema.toCodecStringTree<Schema.Struct<{
+    filters: Schema.optional<Schema.fromJsonString<Schema.Struct<{
+        readonly name: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly driver: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly label: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly dangling: Schema.optional<Schema.$Array<Schema.Literals<readonly ["true", "false", "1", "0"]>>>;
+    }>>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly Volumes: Schema.$Array<typeof Volume>;
+    readonly Warnings: Schema.NullOr<Schema.$Array<Schema.String>>;
+}>>, Schema.toCodecJson<typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", "/volumes/create", never, never, Schema.toCodecJson<typeof VolumeCreateOptions>, never, Schema.toCodecJson<Schema.decodeTo<Schema.declareConstructor<Volume, {
+    readonly Name: string;
+    readonly Options: {
+        readonly [x: string]: string;
+    } | null;
+    readonly Driver: string;
+    readonly Labels: {
+        readonly [x: string]: string;
+    } | null;
+    readonly Scope: string;
+    readonly Mountpoint: string;
+    readonly CreatedAt?: string | undefined;
+    readonly Status?: {
+        readonly [x: string]: object;
+    } | null | undefined;
+    readonly ClusterVolume?: {
+        readonly Spec: {
+            readonly Secrets?: readonly (Schema.Struct.ReadonlySide<{
+                readonly Key: Schema.String;
+                readonly Secret: Schema.String;
+            }, "Encoded"> | null)[] | null | undefined;
+            readonly Group?: string | undefined;
+            readonly AccessMode?: {
+                readonly Scope?: "single" | "multi" | undefined;
+                readonly Sharing?: "readonly" | "none" | "onewriter" | "all" | undefined;
+                readonly MountVolume?: {
+                    readonly FsType?: string | undefined;
+                    readonly MountFlags?: readonly string[] | null | undefined;
+                } | null | undefined;
+                readonly BlockVolume?: Schema.Struct.ReadonlySide<{}, "Encoded"> | null | undefined;
+            } | null | undefined;
+            readonly AccessibilityRequirements?: {
+                readonly Requisite?: readonly ({
+                    readonly Segments?: {
+                        readonly [x: string]: string;
+                    } | null | undefined;
+                } | null)[] | null | undefined;
+                readonly Preferred?: readonly ({
+                    readonly Segments?: {
+                        readonly [x: string]: string;
+                    } | null | undefined;
+                } | null)[] | null | undefined;
+            } | null | undefined;
+            readonly CapacityRange?: Schema.Struct.ReadonlySide<{
+                readonly RequiredBytes: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly LimitBytes: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }, "Encoded"> | null | undefined;
+            readonly Availability?: "active" | "pause" | "drain" | undefined;
+        } | null;
+        readonly ID: string;
+        readonly Version?: {
+            readonly Index?: string | undefined;
+        } | null | undefined;
+        readonly CreatedAt?: string | null | undefined;
+        readonly UpdatedAt?: string | null | undefined;
+        readonly Info?: {
+            readonly AccessibleTopology?: readonly ({
+                readonly Segments?: {
+                    readonly [x: string]: string;
+                } | null | undefined;
+            } | null)[] | null | undefined;
+            readonly CapacityBytes?: string | undefined;
+            readonly VolumeContext?: {
+                readonly [x: string]: string;
+            } | null | undefined;
+            readonly VolumeID?: string | undefined;
+        } | null | undefined;
+        readonly PublishStatus?: readonly ({
+            readonly NodeID?: string | undefined;
+            readonly State?: "pending-publish" | "published" | "pending-node-unpublish" | "pending-controller-unpublish" | undefined;
+            readonly PublishContext?: {
+                readonly [x: string]: string;
+            } | null | undefined;
+        } | null)[] | null | undefined;
+    } | null | undefined;
+    readonly UsageData?: Schema.Struct.ReadonlySide<{
+        readonly RefCount: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        readonly Size: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+    }, "Encoded"> | null | undefined;
+}, readonly [Schema.Struct<{
+    readonly ClusterVolume: Schema.optional<Schema.NullOr<typeof import("../generated/VolumeClusterVolume.generated.ts").VolumeClusterVolume>>;
+    readonly CreatedAt: Schema.optional<Schema.DateFromString>;
+    readonly Driver: Schema.String;
+    readonly Labels: Schema.NullOr<Schema.$Record<Schema.String, Schema.String>>;
+    readonly Mountpoint: Schema.String;
+    readonly Name: Schema.brand<Schema.String, "VolumeId">;
+    readonly Options: Schema.NullOr<Schema.$Record<Schema.String, Schema.String>>;
+    readonly Scope: Schema.String;
+    readonly Status: Schema.optional<Schema.NullOr<Schema.$Record<Schema.String, Schema.ObjectKeyword>>>;
+    readonly UsageData: Schema.optional<Schema.NullOr<typeof import("../generated/VolumeUsageData.generated.ts").VolumeUsageData>>;
+}>], {
+    readonly Name: string & import("effect/Brand").Brand<"VolumeId">;
+    readonly Options: {
+        readonly [x: string]: string;
+    } | null;
+    readonly Driver: string;
+    readonly Labels: {
+        readonly [x: string]: string;
+    } | null;
+    readonly Scope: string;
+    readonly Mountpoint: string;
+    readonly CreatedAt?: Date | undefined;
+    readonly Status?: {
+        readonly [x: string]: object;
+    } | null | undefined;
+    readonly ClusterVolume?: {
+        readonly Spec: {
+            readonly Secrets?: readonly (Schema.Struct.ReadonlySide<{
+                readonly Key: Schema.String;
+                readonly Secret: Schema.String;
+            }, "Iso"> | null)[] | null | undefined;
+            readonly Group?: string | undefined;
+            readonly AccessMode?: {
+                readonly Scope?: "single" | "multi" | undefined;
+                readonly Sharing?: "readonly" | "none" | "onewriter" | "all" | undefined;
+                readonly MountVolume?: {
+                    readonly FsType?: string | undefined;
+                    readonly MountFlags?: readonly string[] | null | undefined;
+                } | null | undefined;
+                readonly BlockVolume?: Schema.Struct.ReadonlySide<{}, "Iso"> | null | undefined;
+            } | null | undefined;
+            readonly AccessibilityRequirements?: {
+                readonly Requisite?: readonly ({
+                    readonly Segments?: {
+                        readonly [x: string]: string;
+                    } | null | undefined;
+                } | null)[] | null | undefined;
+                readonly Preferred?: readonly ({
+                    readonly Segments?: {
+                        readonly [x: string]: string;
+                    } | null | undefined;
+                } | null)[] | null | undefined;
+            } | null | undefined;
+            readonly CapacityRange?: Schema.Struct.ReadonlySide<{
+                readonly RequiredBytes: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly LimitBytes: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }, "Iso"> | null | undefined;
+            readonly Availability?: "active" | "pause" | "drain" | undefined;
+        } | null;
+        readonly ID: string;
+        readonly Version?: {
+            readonly Index?: bigint | undefined;
+        } | null | undefined;
+        readonly CreatedAt?: Date | null | undefined;
+        readonly UpdatedAt?: Date | null | undefined;
+        readonly Info?: {
+            readonly AccessibleTopology?: readonly ({
+                readonly Segments?: {
+                    readonly [x: string]: string;
+                } | null | undefined;
+            } | null)[] | null | undefined;
+            readonly CapacityBytes?: bigint | undefined;
+            readonly VolumeContext?: {
+                readonly [x: string]: string;
+            } | null | undefined;
+            readonly VolumeID?: string | undefined;
+        } | null | undefined;
+        readonly PublishStatus?: readonly ({
+            readonly NodeID?: (string & import("effect/Brand").Brand<"NodeId">) | undefined;
+            readonly State?: "pending-publish" | "published" | "pending-node-unpublish" | "pending-controller-unpublish" | undefined;
+            readonly PublishContext?: {
+                readonly [x: string]: string;
+            } | null | undefined;
+        } | null)[] | null | undefined;
+    } | null | undefined;
+    readonly UsageData?: Schema.Struct.ReadonlySide<{
+        readonly RefCount: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+        readonly Size: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+    }, "Iso"> | null | undefined;
+}>, Schema.Struct<{
+    readonly ClusterVolume: Schema.optional<Schema.NullOr<typeof import("../generated/VolumeClusterVolume.generated.ts").VolumeClusterVolume>>;
+    readonly CreatedAt: Schema.optional<Schema.DateFromString>;
+    readonly Driver: Schema.String;
+    readonly Labels: Schema.NullOr<Schema.$Record<Schema.String, Schema.String>>;
+    readonly Mountpoint: Schema.String;
+    readonly Name: Schema.brand<Schema.String, "VolumeId">;
+    readonly Options: Schema.NullOr<Schema.$Record<Schema.String, Schema.String>>;
+    readonly Scope: Schema.String;
+    readonly Status: Schema.optional<Schema.NullOr<Schema.$Record<Schema.String, Schema.ObjectKeyword>>>;
+    readonly UsageData: Schema.optional<Schema.NullOr<typeof import("../generated/VolumeUsageData.generated.ts").VolumeUsageData>>;
+}>, never, never>>, Schema.toCodecJson<typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"inspect", "GET", "/volumes/:name", Schema.toCodecStringTree<Schema.Struct<{
+    name: Schema.String;
+}>>, never, never, never, Schema.toCodecJson<typeof Volume>, Schema.toCodecJson<typeof NotFound | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"delete", "DELETE", "/volumes/:name", Schema.toCodecStringTree<Schema.Struct<{
+    name: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    force: Schema.optional<Schema.Boolean>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof NotFound | typeof Conflict | typeof InternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"update", "PUT", "/volumes/:name", Schema.toCodecStringTree<Schema.Struct<{
+    name: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    version: Schema.Number;
+}>>, Schema.toCodecJson<typeof ClusterVolumeSpec>, never, Schema.toCodecJson<Schema.Void>, Schema.toCodecJson<typeof BadRequest | typeof NotFound | typeof InternalServerError | typeof ServiceUnavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"prune", "POST", "/volumes/prune", never, Schema.toCodecStringTree<Schema.Struct<{
+    filters: Schema.optional<Schema.fromJsonString<Schema.Struct<{
+        readonly label: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly all: Schema.optional<Schema.$Array<Schema.Literals<readonly ["true", "false", "1", "0"]>>>;
+    }>>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly VolumesDeleted: Schema.optional<Schema.$Array<Schema.brand<Schema.String, "VolumeId">>>;
+    readonly SpaceReclaimed: Schema.BigIntFromString;
+}>>, Schema.toCodecJson<typeof InternalServerError>, never, never>, false>>;
+declare const Volumes_base: Context.ServiceClass<Volumes, "@the-moby-effect/endpoints/Volumes", {
+    list: (filters?: Schema.Schema.Type<typeof ListFilters>) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly Volumes: Schema.$Array<typeof Volume>;
+        readonly Warnings: Schema.NullOr<Schema.$Array<Schema.String>>;
+    }, "Type">, DockerError, never>;
+    create: (options: (typeof VolumeCreateOptions)["~type.make.in"]) => Effect.Effect<Volume, DockerError, never>;
+    inspect: (name: string) => Effect.Effect<Volume, DockerError, never>;
+    delete: (name: string, options?: {
+        force?: boolean | undefined;
+    } | undefined) => Effect.Effect<void, DockerError, never>;
+    update: (name: string, version: number, spec: (typeof ClusterVolumeSpec)["~type.make.in"]) => Effect.Effect<void, DockerError, never>;
+    prune: (filters?: Schema.Schema.Type<typeof PruneFilters>) => Effect.Effect<{
+        readonly SpaceReclaimed: bigint;
+        readonly VolumesDeleted?: readonly (string & import("effect/Brand").Brand<"VolumeId">)[] | undefined;
+    }, DockerError, never>;
+}> & {
+    readonly make: Effect.Effect<{
+        list: (filters?: Schema.Schema.Type<typeof ListFilters>) => Effect.Effect<Schema.Struct.ReadonlySide<{
+            readonly Volumes: Schema.$Array<typeof Volume>;
+            readonly Warnings: Schema.NullOr<Schema.$Array<Schema.String>>;
+        }, "Type">, DockerError, never>;
+        create: (options: (typeof VolumeCreateOptions)["~type.make.in"]) => Effect.Effect<Volume, DockerError, never>;
         inspect: (name: string) => Effect.Effect<Volume, DockerError, never>;
         delete: (name: string, options?: {
             force?: boolean | undefined;
         } | undefined) => Effect.Effect<void, DockerError, never>;
-        update: (name: string, version: number, spec: ClusterVolumeSpec) => Effect.Effect<void, DockerError, never>;
-        prune: (filters?: Schema.Schema.Type<PruneFilters>) => Effect.Effect<{
-            readonly SpaceReclaimed: bigint & import("effect/Brand").Brand<"I64">;
+        update: (name: string, version: number, spec: (typeof ClusterVolumeSpec)["~type.make.in"]) => Effect.Effect<void, DockerError, never>;
+        prune: (filters?: Schema.Schema.Type<typeof PruneFilters>) => Effect.Effect<{
+            readonly SpaceReclaimed: bigint;
             readonly VolumesDeleted?: readonly (string & import("effect/Brand").Brand<"VolumeId">)[] | undefined;
         }, DockerError, never>;
     }, never, HttpClient.HttpClient>;
-}>;
+};
 /**
  * @since 1.0.0
  * @category Services
@@ -86,12 +281,12 @@ export declare class Volumes extends Volumes_base {
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume
  */
-export declare const VolumesLayerLocalSocket: Layer.Layer<Volumes, never, HttpClient.HttpClient>;
+export declare const VolumesLayer: Layer.Layer<Volumes, never, HttpClient.HttpClient>;
 /**
  * @since 1.0.0
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume
  */
-export declare const VolumesLayer: Layer.Layer<Volumes, never, HttpClient.HttpClient>;
+export declare const VolumesLayerLocalSocket: Layer.Layer<Volumes, never, HttpClient.HttpClient>;
 export {};
 //# sourceMappingURL=volumes.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"volumes.d.ts","sourceRoot":"","sources":["../../../src/internal/endpoints/volumes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAiB,eAAe,EAAE,YAAY,EAAiB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACpH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAC;AAKpD,OAAO,EACH,uBAAuB,IAAI,iBAAiB,EAC5C,YAAY,IAAI,MAAM,EACtB,mBAAmB,EACtB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;;;;;;;AAEhD,mBAAmB;AACnB,qBAAa,WAAY,SAAQ,gBAOhC;CAAG;;;;;AAEJ,mBAAmB;AACnB,qBAAa,YAAa,SAAQ,iBAKjC;CAAG;AAgEJ;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;+HAA+C,CAAC;;;;;yBAsBtC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC;;;;0BAE9B,mBAAmB;wBAErB,MAAM;uBACP,MAAM,YAAY;YAAE,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;SAAE,GAAG,SAAS;uBAE7D,MAAM,WAAW,MAAM,QAAQ,iBAAiB;0BAK7C,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC;;;;;;AAhClE;;;;GAIG;AACH,qBAAa,OAAQ,SAAQ,YAuC3B;CAAG;AAEL;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAmB,CAAC;AAE3G;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAsC,CAAC"}
+{"version":3,"file":"volumes.d.ts","sourceRoot":"","sources":["../../../src/internal/endpoints/volumes.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,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,EACH,uBAAuB,IAAI,iBAAiB,EAC5C,YAAY,IAAI,MAAM,EACtB,mBAAmB,EACtB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,mBAAmB,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtG,mBAAmB;AACnB,eAAO,MAAM,WAAW;;;;;GAOvB,CAAC;AAEF,mBAAmB;AACnB,eAAO,MAAM,YAAY;;;GAKxB,CAAC;AA6EF;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAA+C,CAAC;;qBAatC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC;;;;sBAErC,CAAC,OAAO,mBAAmB,EAAE,eAAe,CAAC;oBAK/C,MAAM;mBAEP,MAAM,YAAY;QAAE,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KAAE,GAAG,SAAS;mBAE7D,MAAM,WAAW,MAAM,QAAQ,CAAC,OAAO,iBAAiB,EAAE,eAAe,CAAC;sBAKvE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC;;;;;;yBAhBxC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC;;;;0BAErC,CAAC,OAAO,mBAAmB,EAAE,eAAe,CAAC;wBAK/C,MAAM;uBAEP,MAAM,YAAY;YAAE,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;SAAE,GAAG,SAAS;uBAE7D,MAAM,WAAW,MAAM,QAAQ,CAAC,OAAO,iBAAiB,EAAE,eAAe,CAAC;0BAKvE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC;;;;;;AA3BzE;;;;GAIG;AACH,qBAAa,OAAQ,SAAQ,YAkC3B;CAAG;AAEL;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAuC,CAAC;AAEpH;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAQtF,CAAC"}

package/dist/internal/endpoints/volumes.js

@@ -1,73 +1,113 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
-import { Effect, Schema } from "effect";
-import { I64 } from "effect-schemas/Number";
+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 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 { VolumeClusterVolumeSpec as ClusterVolumeSpec, VolumeVolume as Volume, VolumeCreateOptions } from "../generated/index.js";
 import { VolumeIdentifier } from "../schemas/id.js";
 import { DockerError } from "./circular.js";
-import { BadRequest, Conflict, InternalServerError, NotFound } from "./httpApiHacks.js";
-import { NodeNotPartOfSwarm } from "./swarm.js";
+import { BadRequest, Conflict, 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({
   name: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
   driver: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
   label: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
-  dangling: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Literal("true", "false", "1", "0")))
-})) {}
+  dangling: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Literals(["true", "false", "1", "0"])))
+}));
 /** @since 1.0.0 */
-export class PruneFilters extends /*#__PURE__*/Schema.parseJson(/*#__PURE__*/Schema.Struct({
+export const PruneFilters = /*#__PURE__*/Schema.fromJsonString(/*#__PURE__*/Schema.Struct({
   label: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(Schema.String)),
-  all: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Literal("true", "false", "1", "0")))
-})) {}
+  all: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Literals(["true", "false", "1", "0"])))
+}));
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumeList */
-const listVolumesEndpoint = /*#__PURE__*/HttpApiEndpoint.get("list", "/").setUrlParams(Schema.Struct({
-  filters: Schema.optional(ListFilters)
-})).addSuccess(/*#__PURE__*/Schema.Struct({
-  Volumes: /*#__PURE__*/Schema.Array(Volume),
-  Warnings: /*#__PURE__*/Schema.NullOr(/*#__PURE__*/Schema.Array(Schema.String))
-}), {
-  status: 200
-}); // 200 OK
+const listVolumesEndpoint = /*#__PURE__*/HttpApiEndpoint.get("list", "/", {
+  query: {
+    filters: /*#__PURE__*/Schema.optional(ListFilters)
+  },
+  success: /*#__PURE__*/Schema.Struct({
+    Volumes: /*#__PURE__*/Schema.Array(Volume),
+    Warnings: /*#__PURE__*/Schema.NullOr(/*#__PURE__*/Schema.Array(Schema.String))
+  }),
+  // 200 OK
+  error: [InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumeCreate */
-const createVolumeEndpoint = /*#__PURE__*/HttpApiEndpoint.post("create", "/create").setPayload(VolumeCreateOptions).addSuccess(Volume, {
-  status: 201
-}); // 201 Created
+const createVolumeEndpoint = /*#__PURE__*/HttpApiEndpoint.post("create", "/create", {
+  payload: VolumeCreateOptions,
+  success: /*#__PURE__*/Volume.pipe(/*#__PURE__*/HttpApiSchema.status(201)),
+  // 201 Created
+  error: [InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumeInspect */
-const inspectVolumeEndpoint = /*#__PURE__*/HttpApiEndpoint.get("inspect", "/:name").setPath(Schema.Struct({
-  name: Schema.String
-})).addSuccess(Volume, {
-  status: 200
-}) // 200 OK
-.addError(NotFound); // 404 Volume not found
+const inspectVolumeEndpoint = /*#__PURE__*/HttpApiEndpoint.get("inspect", "/:name", {
+  params: {
+    name: Schema.String
+  },
+  success: Volume,
+  // 200 OK
+  error: [NotFound,
+  // 404 Volume not found
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumeDelete */
-const deleteVolumeEndpoint = /*#__PURE__*/HttpApiEndpoint.del("delete", "/:name").setPath(Schema.Struct({
-  name: Schema.String
-})).setUrlParams(Schema.Struct({
-  force: Schema.optional(Schema.BooleanFromString)
-})).addSuccess(HttpApiSchema.NoContent) // 204 No Content
-.addError(NotFound) // 404 Volume not found
-.addError(Conflict); // 409 Volume is in use
+const deleteVolumeEndpoint = /*#__PURE__*/HttpApiEndpoint.delete("delete", "/:name", {
+  params: {
+    name: Schema.String
+  },
+  query: {
+    force: /*#__PURE__*/Schema.optional(Schema.Boolean)
+  },
+  success: HttpApiSchema.NoContent,
+  // 204 No Content
+  error: [NotFound,
+  // 404 Volume not found
+  Conflict,
+  // 409 Volume is in use
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumeUpdate */
-const updateVolumeEndpoint = /*#__PURE__*/HttpApiEndpoint.put("update", "/:name").setPath(Schema.Struct({
-  name: Schema.String
-})).setUrlParams(Schema.Struct({
-  version: Schema.NumberFromString
-})).setPayload(ClusterVolumeSpec).addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-.addError(BadRequest) // 400 Bad parameter
-.addError(NotFound) // 404 Volume not found
-.addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const updateVolumeEndpoint = /*#__PURE__*/HttpApiEndpoint.put("update", "/:name", {
+  params: {
+    name: Schema.String
+  },
+  query: {
+    version: Schema.Number
+  },
+  payload: ClusterVolumeSpec,
+  success: /*#__PURE__*/HttpApiSchema.Empty(200),
+  // 200 OK
+  error: [BadRequest,
+  // 400 Bad parameter
+  NotFound,
+  // 404 Volume not found
+  ServiceUnavailable,
+  // 503 Node is not part of a swarm
+  InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumePrune */
-const pruneVolumeEndpoint = /*#__PURE__*/HttpApiEndpoint.post("prune", "/prune").setUrlParams(Schema.Struct({
-  filters: Schema.optional(PruneFilters)
-})).addSuccess(/*#__PURE__*/Schema.Struct({
-  VolumesDeleted: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(VolumeIdentifier)),
-  SpaceReclaimed: I64
-}), {
-  status: 200
-}); // 200 OK
+const pruneVolumeEndpoint = /*#__PURE__*/HttpApiEndpoint.post("prune", "/prune", {
+  query: {
+    filters: /*#__PURE__*/Schema.optional(PruneFilters)
+  },
+  success: /*#__PURE__*/Schema.Struct({
+    VolumesDeleted: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Array(VolumeIdentifier)),
+    SpaceReclaimed: /*#__PURE__*/Schema.BigIntFromString.check(/*#__PURE__*/Schema.isBetweenBigInt({
+      minimum: 0n,
+      maximum: 2n ** 64n - 1n
+    }))
+  }),
+  // 200 OK
+  error: [InternalServerError]
+});
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume */
-const VolumesGroup = /*#__PURE__*/HttpApiGroup.make("volumes").add(listVolumesEndpoint).add(createVolumeEndpoint).add(inspectVolumeEndpoint).add(deleteVolumeEndpoint).add(updateVolumeEndpoint).add(pruneVolumeEndpoint).addError(InternalServerError).prefix("/volumes");
+const VolumesGroup = /*#__PURE__*/HttpApiGroup.make("volumes").add(listVolumesEndpoint, createVolumeEndpoint, inspectVolumeEndpoint, deleteVolumeEndpoint, updateVolumeEndpoint, pruneVolumeEndpoint).prefix("/volumes");
 /**
  * @since 1.0.0
  * @category HttpApi
@@ -79,53 +119,49 @@ export const VolumesApi = /*#__PURE__*/HttpApi.make("VolumesApi").add(VolumesGro
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume
  */
-export class Volumes extends /*#__PURE__*/Effect.Service()("@the-moby-effect/endpoints/Volumes", {
-  accessors: false,
-  dependencies: [/*#__PURE__*/makeAgnosticHttpClientLayer(/*#__PURE__*/MobyConnectionOptions.socket({
-    socketPath: "/var/run/docker.sock"
-  }))],
-  effect: /*#__PURE__*/Effect.gen(function* () {
+export class Volumes extends /*#__PURE__*/Context.Service()("@the-moby-effect/endpoints/Volumes", {
+  make: /*#__PURE__*/Effect.gen(function* () {
     const httpClient = yield* HttpClient.HttpClient;
     const VolumesError = DockerError.WrapForModule("volumes");
     const client = yield* HttpApiClient.group(VolumesApi, {
       group: "volumes",
       httpClient
     });
-    const list_ = filters => Effect.mapError(client.list({
-      urlParams: {
+    const list_ = filters => client.list({
+      query: {
         filters
       }
-    }), VolumesError("list"));
-    const create_ = options => Effect.mapError(client.create({
-      payload: options
-    }), VolumesError("create"));
-    const inspect_ = name => Effect.mapError(client.inspect({
-      path: {
+    }).pipe(Effect.mapError(VolumesError("list")));
+    const create_ = options => VolumeCreateOptions.makeEffect(options).pipe(Effect.flatMap(payload => client.create({
+      payload
+    })), Effect.mapError(VolumesError("create")));
+    const inspect_ = name => client.inspect({
+      params: {
         name
       }
-    }), VolumesError("inspect"));
-    const delete_ = (name, options) => Effect.mapError(client.delete({
-      path: {
+    }).pipe(Effect.mapError(VolumesError("inspect")));
+    const delete_ = (name, options) => client.delete({
+      params: {
         name
       },
-      urlParams: {
+      query: {
         ...options
       }
-    }), VolumesError("delete"));
-    const update_ = (name, version, spec) => Effect.mapError(client.update({
-      path: {
+    }).pipe(Effect.mapError(VolumesError("delete")));
+    const update_ = (name, version, spec) => ClusterVolumeSpec.makeEffect(spec).pipe(Effect.flatMap(payload => client.update({
+      params: {
         name
       },
-      urlParams: {
+      query: {
         version
       },
-      payload: spec
-    }), VolumesError("update"));
-    const prune_ = filters => Effect.mapError(client.prune({
-      urlParams: {
+      payload
+    })), Effect.mapError(VolumesError("update")));
+    const prune_ = filters => client.prune({
+      query: {
         filters
       }
-    }), VolumesError("prune"));
+    }).pipe(Effect.mapError(VolumesError("prune")));
     return {
       list: list_,
       create: create_,
@@ -141,11 +177,13 @@ export class Volumes extends /*#__PURE__*/Effect.Service()("@the-moby-effect/end
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume
  */
-export const VolumesLayerLocalSocket = Volumes.Default;
+export const VolumesLayer = /*#__PURE__*/Layer.effect(Volumes, Volumes.make);
 /**
  * @since 1.0.0
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume
  */
-export const VolumesLayer = Volumes.DefaultWithoutDependencies;
+export const VolumesLayerLocalSocket = /*#__PURE__*/VolumesLayer.pipe(/*#__PURE__*/Layer.provide(/*#__PURE__*/makeAgnosticHttpClientLayer(/*#__PURE__*/MobyConnectionOptions.socket({
+  socketPath: "/var/run/docker.sock"
+}))));
 //# sourceMappingURL=volumes.js.map