the-moby-effect 1.45.0-alpha.2 → 1.45.0-alpha.21

package/dist/dts/generated/SwarmNetworkSpec.generated.d.ts

@@ -0,0 +1,65 @@
+import * as Schema from "effect/Schema";
+import * as NetworkConfigReference from "./NetworkConfigReference.generated.js";
+import * as SwarmDriver from "./SwarmDriver.generated.js";
+import * as SwarmIPAMOptions from "./SwarmIPAMOptions.generated.js";
+declare const SwarmNetworkSpec_base: Schema.Class<SwarmNetworkSpec, {
+    DriverConfiguration: Schema.optionalWith<typeof SwarmDriver.SwarmDriver, {
+        nullable: true;
+    }>;
+    IPv6Enabled: Schema.optional<typeof Schema.Boolean>;
+    Internal: Schema.optional<typeof Schema.Boolean>;
+    Attachable: Schema.optional<typeof Schema.Boolean>;
+    Ingress: Schema.optional<typeof Schema.Boolean>;
+    IPAMOptions: Schema.optionalWith<typeof SwarmIPAMOptions.SwarmIPAMOptions, {
+        nullable: true;
+    }>;
+    ConfigFrom: Schema.optionalWith<typeof NetworkConfigReference.NetworkConfigReference, {
+        nullable: true;
+    }>;
+    Scope: Schema.optional<typeof Schema.String>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}, Schema.Struct.Encoded<{
+    DriverConfiguration: Schema.optionalWith<typeof SwarmDriver.SwarmDriver, {
+        nullable: true;
+    }>;
+    IPv6Enabled: Schema.optional<typeof Schema.Boolean>;
+    Internal: Schema.optional<typeof Schema.Boolean>;
+    Attachable: Schema.optional<typeof Schema.Boolean>;
+    Ingress: Schema.optional<typeof Schema.Boolean>;
+    IPAMOptions: Schema.optionalWith<typeof SwarmIPAMOptions.SwarmIPAMOptions, {
+        nullable: true;
+    }>;
+    ConfigFrom: Schema.optionalWith<typeof NetworkConfigReference.NetworkConfigReference, {
+        nullable: true;
+    }>;
+    Scope: Schema.optional<typeof Schema.String>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}>, never, {
+    readonly Scope?: string | undefined;
+} & {
+    readonly Name?: string | undefined;
+} & {
+    readonly Labels: {
+        readonly [x: string]: string;
+    } | null;
+} & {
+    readonly Internal?: boolean | undefined;
+} & {
+    readonly Attachable?: boolean | undefined;
+} & {
+    readonly Ingress?: boolean | undefined;
+} & {
+    readonly ConfigFrom?: NetworkConfigReference.NetworkConfigReference | undefined;
+} & {
+    readonly DriverConfiguration?: SwarmDriver.SwarmDriver | undefined;
+} & {
+    readonly IPv6Enabled?: boolean | undefined;
+} & {
+    readonly IPAMOptions?: SwarmIPAMOptions.SwarmIPAMOptions | undefined;
+}, {}, {}>;
+export declare class SwarmNetworkSpec extends SwarmNetworkSpec_base {
+}
+export {};
+//# sourceMappingURL=SwarmNetworkSpec.generated.d.ts.map

package/dist/dts/generated/SwarmNetworkSpec.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmNetworkSpec.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmNetworkSpec.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,sBAAsB,MAAM,uCAAuC,CAAC;AAEhF,OAAO,KAAK,WAAW,MAAM,4BAA4B,CAAC;AAC1D,OAAO,KAAK,gBAAgB,MAAM,iCAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpE,qBAAa,gBAAiB,SAAQ,qBAkBrC;CAAG"}

package/dist/dts/generated/SwarmNode.generated.d.ts

@@ -0,0 +1,72 @@
+import * as Schema from "effect/Schema";
+import * as SwarmManagerStatus from "./SwarmManagerStatus.generated.js";
+import * as SwarmNodeDescription from "./SwarmNodeDescription.generated.js";
+import * as SwarmNodeSpec from "./SwarmNodeSpec.generated.js";
+import * as SwarmNodeStatus from "./SwarmNodeStatus.generated.js";
+declare const SwarmNode_base: Schema.Class<SwarmNode, {
+    Spec: Schema.optionalWith<typeof SwarmNodeSpec.SwarmNodeSpec, {
+        nullable: true;
+    }>;
+    Description: Schema.optionalWith<typeof SwarmNodeDescription.SwarmNodeDescription, {
+        nullable: true;
+    }>;
+    Status: Schema.optionalWith<typeof SwarmNodeStatus.SwarmNodeStatus, {
+        nullable: true;
+    }>;
+    ManagerStatus: Schema.optionalWith<typeof SwarmManagerStatus.SwarmManagerStatus, {
+        nullable: true;
+    }>;
+    Version: Schema.optionalWith<typeof import("./SwarmVersion.generated.js").SwarmVersion, {
+        nullable: true;
+    }>;
+    CreatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    UpdatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    ID: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    Spec: Schema.optionalWith<typeof SwarmNodeSpec.SwarmNodeSpec, {
+        nullable: true;
+    }>;
+    Description: Schema.optionalWith<typeof SwarmNodeDescription.SwarmNodeDescription, {
+        nullable: true;
+    }>;
+    Status: Schema.optionalWith<typeof SwarmNodeStatus.SwarmNodeStatus, {
+        nullable: true;
+    }>;
+    ManagerStatus: Schema.optionalWith<typeof SwarmManagerStatus.SwarmManagerStatus, {
+        nullable: true;
+    }>;
+    Version: Schema.optionalWith<typeof import("./SwarmVersion.generated.js").SwarmVersion, {
+        nullable: true;
+    }>;
+    CreatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    UpdatedAt: Schema.optionalWith<typeof Schema.DateFromString, {
+        nullable: true;
+    }>;
+    ID: typeof Schema.String;
+}>, never, {
+    readonly ID: string;
+} & {
+    readonly Description?: SwarmNodeDescription.SwarmNodeDescription | undefined;
+} & {
+    readonly CreatedAt?: Date | undefined;
+} & {
+    readonly Version?: import("./SwarmVersion.generated.js").SwarmVersion | undefined;
+} & {
+    readonly UpdatedAt?: Date | undefined;
+} & {
+    readonly Spec?: SwarmNodeSpec.SwarmNodeSpec | undefined;
+} & {
+    readonly Status?: SwarmNodeStatus.SwarmNodeStatus | undefined;
+} & {
+    readonly ManagerStatus?: SwarmManagerStatus.SwarmManagerStatus | undefined;
+}, {}, {}>;
+export declare class SwarmNode extends SwarmNode_base {
+}
+export {};
+//# sourceMappingURL=SwarmNode.generated.d.ts.map

package/dist/dts/generated/SwarmNode.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmNode.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmNode.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,kBAAkB,MAAM,mCAAmC,CAAC;AAExE,OAAO,KAAK,oBAAoB,MAAM,qCAAqC,CAAC;AAC5E,OAAO,KAAK,aAAa,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,eAAe,MAAM,gCAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElE,qBAAa,SAAU,SAAQ,cAe9B;CAAG"}

package/dist/dts/generated/SwarmNodeCSIInfo.generated.d.ts

@@ -0,0 +1,30 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+import * as SwarmTopology from "./SwarmTopology.generated.js";
+declare const SwarmNodeCSIInfo_base: Schema.Class<SwarmNodeCSIInfo, {
+    PluginName: Schema.optional<typeof Schema.String>;
+    NodeID: Schema.optional<typeof Schema.String>;
+    MaxVolumesPerNode: Schema.optional<MobySchemas.Int64Schemas.$Int64>;
+    AccessibleTopology: Schema.optionalWith<typeof SwarmTopology.SwarmTopology, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    PluginName: Schema.optional<typeof Schema.String>;
+    NodeID: Schema.optional<typeof Schema.String>;
+    MaxVolumesPerNode: Schema.optional<MobySchemas.Int64Schemas.$Int64>;
+    AccessibleTopology: Schema.optionalWith<typeof SwarmTopology.SwarmTopology, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly AccessibleTopology?: SwarmTopology.SwarmTopology | undefined;
+} & {
+    readonly NodeID?: string | undefined;
+} & {
+    readonly PluginName?: string | undefined;
+} & {
+    readonly MaxVolumesPerNode?: MobySchemas.Int64Schemas.Int64Brand | undefined;
+}, {}, {}>;
+export declare class SwarmNodeCSIInfo extends SwarmNodeCSIInfo_base {
+}
+export {};
+//# sourceMappingURL=SwarmNodeCSIInfo.generated.d.ts.map

package/dist/dts/generated/SwarmNodeCSIInfo.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmNodeCSIInfo.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmNodeCSIInfo.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,aAAa,MAAM,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAE9D,qBAAa,gBAAiB,SAAQ,qBAarC;CAAG"}

package/dist/dts/generated/SwarmNodeDescription.generated.d.ts

@@ -0,0 +1,57 @@
+import * as Schema from "effect/Schema";
+import * as SwarmEngineDescription from "./SwarmEngineDescription.generated.js";
+import * as SwarmNodeCSIInfo from "./SwarmNodeCSIInfo.generated.js";
+import * as SwarmPlatform from "./SwarmPlatform.generated.js";
+import * as SwarmResources from "./SwarmResources.generated.js";
+import * as SwarmTLSInfo from "./SwarmTLSInfo.generated.js";
+declare const SwarmNodeDescription_base: Schema.Class<SwarmNodeDescription, {
+    Hostname: Schema.optional<typeof Schema.String>;
+    Platform: Schema.optionalWith<typeof SwarmPlatform.SwarmPlatform, {
+        nullable: true;
+    }>;
+    Resources: Schema.optionalWith<typeof SwarmResources.SwarmResources, {
+        nullable: true;
+    }>;
+    Engine: Schema.optionalWith<typeof SwarmEngineDescription.SwarmEngineDescription, {
+        nullable: true;
+    }>;
+    TLSInfo: Schema.optionalWith<typeof SwarmTLSInfo.SwarmTLSInfo, {
+        nullable: true;
+    }>;
+    CSIInfo: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmNodeCSIInfo.SwarmNodeCSIInfo>>, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    Hostname: Schema.optional<typeof Schema.String>;
+    Platform: Schema.optionalWith<typeof SwarmPlatform.SwarmPlatform, {
+        nullable: true;
+    }>;
+    Resources: Schema.optionalWith<typeof SwarmResources.SwarmResources, {
+        nullable: true;
+    }>;
+    Engine: Schema.optionalWith<typeof SwarmEngineDescription.SwarmEngineDescription, {
+        nullable: true;
+    }>;
+    TLSInfo: Schema.optionalWith<typeof SwarmTLSInfo.SwarmTLSInfo, {
+        nullable: true;
+    }>;
+    CSIInfo: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmNodeCSIInfo.SwarmNodeCSIInfo>>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly Hostname?: string | undefined;
+} & {
+    readonly Platform?: SwarmPlatform.SwarmPlatform | undefined;
+} & {
+    readonly TLSInfo?: SwarmTLSInfo.SwarmTLSInfo | undefined;
+} & {
+    readonly Resources?: SwarmResources.SwarmResources | undefined;
+} & {
+    readonly Engine?: SwarmEngineDescription.SwarmEngineDescription | undefined;
+} & {
+    readonly CSIInfo?: readonly (SwarmNodeCSIInfo.SwarmNodeCSIInfo | null)[] | undefined;
+}, {}, {}>;
+export declare class SwarmNodeDescription extends SwarmNodeDescription_base {
+}
+export {};
+//# sourceMappingURL=SwarmNodeDescription.generated.d.ts.map

package/dist/dts/generated/SwarmNodeDescription.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmNodeDescription.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmNodeDescription.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,sBAAsB,MAAM,uCAAuC,CAAC;AAChF,OAAO,KAAK,gBAAgB,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,aAAa,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,cAAc,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,YAAY,MAAM,6BAA6B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5D,qBAAa,oBAAqB,SAAQ,yBAiBzC;CAAG"}

package/dist/dts/generated/SwarmNodeSpec.generated.d.ts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+declare const SwarmNodeSpec_base: Schema.Class<SwarmNodeSpec, {
+    Role: Schema.optional<typeof Schema.String>;
+    Availability: Schema.optional<typeof Schema.String>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}, Schema.Struct.Encoded<{
+    Role: Schema.optional<typeof Schema.String>;
+    Availability: Schema.optional<typeof Schema.String>;
+    Name: Schema.optional<typeof Schema.String>;
+    Labels: Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}>, never, {
+    readonly Availability?: string | undefined;
+} & {
+    readonly Name?: string | undefined;
+} & {
+    readonly Labels: {
+        readonly [x: string]: string;
+    } | null;
+} & {
+    readonly Role?: string | undefined;
+}, {}, {}>;
+export declare class SwarmNodeSpec extends SwarmNodeSpec_base {
+}
+export {};
+//# sourceMappingURL=SwarmNodeSpec.generated.d.ts.map

package/dist/dts/generated/SwarmNodeSpec.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmNodeSpec.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmNodeSpec.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;AAGxC,qBAAa,aAAc,SAAQ,kBAYlC;CAAG"}

package/dist/dts/generated/SwarmNodeStatus.generated.d.ts

@@ -0,0 +1,20 @@
+import * as Schema from "effect/Schema";
+declare const SwarmNodeStatus_base: Schema.Class<SwarmNodeStatus, {
+    State: Schema.optional<typeof Schema.String>;
+    Message: Schema.optional<typeof Schema.String>;
+    Addr: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    State: Schema.optional<typeof Schema.String>;
+    Message: Schema.optional<typeof Schema.String>;
+    Addr: Schema.optional<typeof Schema.String>;
+}>, never, {
+    readonly State?: string | undefined;
+} & {
+    readonly Addr?: string | undefined;
+} & {
+    readonly Message?: string | undefined;
+}, {}, {}>;
+export declare class SwarmNodeStatus extends SwarmNodeStatus_base {
+}
+export {};
+//# sourceMappingURL=SwarmNodeStatus.generated.d.ts.map

package/dist/dts/generated/SwarmNodeStatus.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmNodeStatus.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmNodeStatus.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;AAExC,qBAAa,eAAgB,SAAQ,oBAYpC;CAAG"}

package/dist/dts/generated/SwarmOrchestrationConfig.generated.d.ts

@@ -0,0 +1,17 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+declare const SwarmOrchestrationConfig_base: Schema.Class<SwarmOrchestrationConfig, {
+    TaskHistoryRetentionLimit: Schema.optionalWith<MobySchemas.Int64Schemas.$Int64, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    TaskHistoryRetentionLimit: Schema.optionalWith<MobySchemas.Int64Schemas.$Int64, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly TaskHistoryRetentionLimit?: MobySchemas.Int64Schemas.Int64Brand | undefined;
+}, {}, {}>;
+export declare class SwarmOrchestrationConfig extends SwarmOrchestrationConfig_base {
+}
+export {};
+//# sourceMappingURL=SwarmOrchestrationConfig.generated.d.ts.map

package/dist/dts/generated/SwarmOrchestrationConfig.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmOrchestrationConfig.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmOrchestrationConfig.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;;;;;;;;;;;;AAEnD,qBAAa,wBAAyB,SAAQ,6BAU7C;CAAG"}

package/dist/dts/generated/SwarmPeer.generated.d.ts

@@ -0,0 +1,16 @@
+import * as Schema from "effect/Schema";
+declare const SwarmPeer_base: Schema.Class<SwarmPeer, {
+    NodeID: typeof Schema.String;
+    Addr: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    NodeID: typeof Schema.String;
+    Addr: typeof Schema.String;
+}>, never, {
+    readonly NodeID: string;
+} & {
+    readonly Addr: string;
+}, {}, {}>;
+export declare class SwarmPeer extends SwarmPeer_base {
+}
+export {};
+//# sourceMappingURL=SwarmPeer.generated.d.ts.map

package/dist/dts/generated/SwarmPeer.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmPeer.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmPeer.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;;;;;AAExC,qBAAa,SAAU,SAAQ,cAW9B;CAAG"}

package/dist/dts/generated/SwarmPlacement.generated.d.ts

@@ -0,0 +1,39 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+import * as SwarmPlacementPreference from "./SwarmPlacementPreference.generated.js";
+import * as SwarmPlatform from "./SwarmPlatform.generated.js";
+declare const SwarmPlacement_base: Schema.Class<SwarmPlacement, {
+    Constraints: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+        nullable: true;
+    }>;
+    Preferences: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmPlacementPreference.SwarmPlacementPreference>>, {
+        nullable: true;
+    }>;
+    MaxReplicas: Schema.optional<MobySchemas.UInt64Schemas.$UInt64>;
+    Platforms: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmPlatform.SwarmPlatform>>, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    Constraints: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+        nullable: true;
+    }>;
+    Preferences: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmPlacementPreference.SwarmPlacementPreference>>, {
+        nullable: true;
+    }>;
+    MaxReplicas: Schema.optional<MobySchemas.UInt64Schemas.$UInt64>;
+    Platforms: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmPlatform.SwarmPlatform>>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly Platforms?: readonly (SwarmPlatform.SwarmPlatform | null)[] | undefined;
+} & {
+    readonly Constraints?: readonly string[] | undefined;
+} & {
+    readonly Preferences?: readonly (SwarmPlacementPreference.SwarmPlacementPreference | null)[] | undefined;
+} & {
+    readonly MaxReplicas?: MobySchemas.UInt64Schemas.UInt64Brand | undefined;
+}, {}, {}>;
+export declare class SwarmPlacement extends SwarmPlacement_base {
+}
+export {};
+//# sourceMappingURL=SwarmPlacement.generated.d.ts.map

package/dist/dts/generated/SwarmPlacement.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmPlacement.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmPlacement.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,wBAAwB,MAAM,yCAAyC,CAAC;AACpF,OAAO,KAAK,aAAa,MAAM,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9D,qBAAa,cAAe,SAAQ,mBAoBnC;CAAG"}

package/dist/dts/generated/SwarmPlacementPreference.generated.d.ts

@@ -0,0 +1,13 @@
+import * as Schema from "effect/Schema";
+import * as SwarmSpreadOver from "./SwarmSpreadOver.generated.js";
+declare const SwarmPlacementPreference_base: Schema.Class<SwarmPlacementPreference, {
+    Spread: Schema.NullOr<typeof SwarmSpreadOver.SwarmSpreadOver>;
+}, Schema.Struct.Encoded<{
+    Spread: Schema.NullOr<typeof SwarmSpreadOver.SwarmSpreadOver>;
+}>, never, {
+    readonly Spread: SwarmSpreadOver.SwarmSpreadOver | null;
+}, {}, {}>;
+export declare class SwarmPlacementPreference extends SwarmPlacementPreference_base {
+}
+export {};
+//# sourceMappingURL=SwarmPlacementPreference.generated.d.ts.map

package/dist/dts/generated/SwarmPlacementPreference.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmPlacementPreference.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmPlacementPreference.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,eAAe,MAAM,gCAAgC,CAAC;;;;;;;;AAElE,qBAAa,wBAAyB,SAAQ,6BAU7C;CAAG"}

package/dist/dts/generated/SwarmPlatform.generated.d.ts

@@ -0,0 +1,16 @@
+import * as Schema from "effect/Schema";
+declare const SwarmPlatform_base: Schema.Class<SwarmPlatform, {
+    Architecture: Schema.optional<typeof Schema.String>;
+    OS: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    Architecture: Schema.optional<typeof Schema.String>;
+    OS: Schema.optional<typeof Schema.String>;
+}>, never, {
+    readonly Architecture?: string | undefined;
+} & {
+    readonly OS?: string | undefined;
+}, {}, {}>;
+export declare class SwarmPlatform extends SwarmPlatform_base {
+}
+export {};
+//# sourceMappingURL=SwarmPlatform.generated.d.ts.map

package/dist/dts/generated/SwarmPlatform.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmPlatform.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmPlatform.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;;;;;AAExC,qBAAa,aAAc,SAAQ,kBAWlC;CAAG"}

package/dist/dts/generated/SwarmPluginDescription.generated.d.ts

@@ -0,0 +1,16 @@
+import * as Schema from "effect/Schema";
+declare const SwarmPluginDescription_base: Schema.Class<SwarmPluginDescription, {
+    Type: Schema.optional<typeof Schema.String>;
+    Name: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    Type: Schema.optional<typeof Schema.String>;
+    Name: Schema.optional<typeof Schema.String>;
+}>, never, {
+    readonly Type?: string | undefined;
+} & {
+    readonly Name?: string | undefined;
+}, {}, {}>;
+export declare class SwarmPluginDescription extends SwarmPluginDescription_base {
+}
+export {};
+//# sourceMappingURL=SwarmPluginDescription.generated.d.ts.map

package/dist/dts/generated/SwarmPluginDescription.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmPluginDescription.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmPluginDescription.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;;;;;AAExC,qBAAa,sBAAuB,SAAQ,2BAW3C;CAAG"}

package/dist/dts/generated/SwarmPortConfig.generated.d.ts

@@ -0,0 +1,29 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+declare const SwarmPortConfig_base: Schema.Class<SwarmPortConfig, {
+    Name: Schema.optional<typeof Schema.String>;
+    Protocol: Schema.optional<typeof Schema.String>;
+    TargetPort: Schema.optional<MobySchemas.UInt32Schemas.$UInt32>;
+    PublishedPort: Schema.optional<MobySchemas.UInt32Schemas.$UInt32>;
+    PublishMode: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    Name: Schema.optional<typeof Schema.String>;
+    Protocol: Schema.optional<typeof Schema.String>;
+    TargetPort: Schema.optional<MobySchemas.UInt32Schemas.$UInt32>;
+    PublishedPort: Schema.optional<MobySchemas.UInt32Schemas.$UInt32>;
+    PublishMode: Schema.optional<typeof Schema.String>;
+}>, never, {
+    readonly Name?: string | undefined;
+} & {
+    readonly Protocol?: string | undefined;
+} & {
+    readonly TargetPort?: MobySchemas.UInt32Schemas.UInt32Brand | undefined;
+} & {
+    readonly PublishedPort?: MobySchemas.UInt32Schemas.UInt32Brand | undefined;
+} & {
+    readonly PublishMode?: string | undefined;
+}, {}, {}>;
+export declare class SwarmPortConfig extends SwarmPortConfig_base {
+}
+export {};
+//# sourceMappingURL=SwarmPortConfig.generated.d.ts.map

package/dist/dts/generated/SwarmPortConfig.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmPortConfig.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmPortConfig.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAEnD,qBAAa,eAAgB,SAAQ,oBAepC;CAAG"}

package/dist/dts/generated/SwarmPortStatus.generated.d.ts

@@ -0,0 +1,17 @@
+import * as Schema from "effect/Schema";
+import * as SwarmPortConfig from "./SwarmPortConfig.generated.js";
+declare const SwarmPortStatus_base: Schema.Class<SwarmPortStatus, {
+    Ports: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmPortConfig.SwarmPortConfig>>, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    Ports: Schema.optionalWith<Schema.Array$<Schema.NullOr<typeof SwarmPortConfig.SwarmPortConfig>>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly Ports?: readonly (SwarmPortConfig.SwarmPortConfig | null)[] | undefined;
+}, {}, {}>;
+export declare class SwarmPortStatus extends SwarmPortStatus_base {
+}
+export {};
+//# sourceMappingURL=SwarmPortStatus.generated.d.ts.map

package/dist/dts/generated/SwarmPortStatus.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmPortStatus.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmPortStatus.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,eAAe,MAAM,gCAAgC,CAAC;;;;;;;;;;;;AAElE,qBAAa,eAAgB,SAAQ,oBAYpC;CAAG"}

package/dist/dts/generated/SwarmPrivileges.generated.d.ts

@@ -0,0 +1,40 @@
+import * as Schema from "effect/Schema";
+import * as SwarmAppArmorOpts from "./SwarmAppArmorOpts.generated.js";
+import * as SwarmCredentialSpec from "./SwarmCredentialSpec.generated.js";
+import * as SwarmSELinuxContext from "./SwarmSELinuxContext.generated.js";
+import * as SwarmSeccompOpts from "./SwarmSeccompOpts.generated.js";
+declare const SwarmPrivileges_base: Schema.Class<SwarmPrivileges, {
+    CredentialSpec: Schema.NullOr<typeof SwarmCredentialSpec.SwarmCredentialSpec>;
+    SELinuxContext: Schema.NullOr<typeof SwarmSELinuxContext.SwarmSELinuxContext>;
+    Seccomp: Schema.optionalWith<typeof SwarmSeccompOpts.SwarmSeccompOpts, {
+        nullable: true;
+    }>;
+    AppArmor: Schema.optionalWith<typeof SwarmAppArmorOpts.SwarmAppArmorOpts, {
+        nullable: true;
+    }>;
+    NoNewPrivileges: typeof Schema.Boolean;
+}, Schema.Struct.Encoded<{
+    CredentialSpec: Schema.NullOr<typeof SwarmCredentialSpec.SwarmCredentialSpec>;
+    SELinuxContext: Schema.NullOr<typeof SwarmSELinuxContext.SwarmSELinuxContext>;
+    Seccomp: Schema.optionalWith<typeof SwarmSeccompOpts.SwarmSeccompOpts, {
+        nullable: true;
+    }>;
+    AppArmor: Schema.optionalWith<typeof SwarmAppArmorOpts.SwarmAppArmorOpts, {
+        nullable: true;
+    }>;
+    NoNewPrivileges: typeof Schema.Boolean;
+}>, never, {
+    readonly NoNewPrivileges: boolean;
+} & {
+    readonly CredentialSpec: SwarmCredentialSpec.SwarmCredentialSpec | null;
+} & {
+    readonly SELinuxContext: SwarmSELinuxContext.SwarmSELinuxContext | null;
+} & {
+    readonly Seccomp?: SwarmSeccompOpts.SwarmSeccompOpts | undefined;
+} & {
+    readonly AppArmor?: SwarmAppArmorOpts.SwarmAppArmorOpts | undefined;
+}, {}, {}>;
+export declare class SwarmPrivileges extends SwarmPrivileges_base {
+}
+export {};
+//# sourceMappingURL=SwarmPrivileges.generated.d.ts.map

package/dist/dts/generated/SwarmPrivileges.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmPrivileges.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmPrivileges.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,iBAAiB,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,mBAAmB,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,mBAAmB,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,gBAAgB,MAAM,iCAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpE,qBAAa,eAAgB,SAAQ,oBAcpC;CAAG"}

package/dist/dts/generated/SwarmRaftConfig.generated.d.ts

@@ -0,0 +1,33 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+declare const SwarmRaftConfig_base: Schema.Class<SwarmRaftConfig, {
+    SnapshotInterval: Schema.optional<MobySchemas.UInt64Schemas.$UInt64>;
+    KeepOldSnapshots: Schema.optionalWith<MobySchemas.UInt64Schemas.$UInt64, {
+        nullable: true;
+    }>;
+    LogEntriesForSlowFollowers: Schema.optional<MobySchemas.UInt64Schemas.$UInt64>;
+    ElectionTick: MobySchemas.Int64Schemas.$Int64;
+    HeartbeatTick: MobySchemas.Int64Schemas.$Int64;
+}, Schema.Struct.Encoded<{
+    SnapshotInterval: Schema.optional<MobySchemas.UInt64Schemas.$UInt64>;
+    KeepOldSnapshots: Schema.optionalWith<MobySchemas.UInt64Schemas.$UInt64, {
+        nullable: true;
+    }>;
+    LogEntriesForSlowFollowers: Schema.optional<MobySchemas.UInt64Schemas.$UInt64>;
+    ElectionTick: MobySchemas.Int64Schemas.$Int64;
+    HeartbeatTick: MobySchemas.Int64Schemas.$Int64;
+}>, never, {
+    readonly ElectionTick: MobySchemas.Int64Schemas.Int64Brand;
+} & {
+    readonly HeartbeatTick: MobySchemas.Int64Schemas.Int64Brand;
+} & {
+    readonly SnapshotInterval?: MobySchemas.UInt64Schemas.UInt64Brand | undefined;
+} & {
+    readonly KeepOldSnapshots?: MobySchemas.UInt64Schemas.UInt64Brand | undefined;
+} & {
+    readonly LogEntriesForSlowFollowers?: MobySchemas.UInt64Schemas.UInt64Brand | undefined;
+}, {}, {}>;
+export declare class SwarmRaftConfig extends SwarmRaftConfig_base {
+}
+export {};
+//# sourceMappingURL=SwarmRaftConfig.generated.d.ts.map

package/dist/dts/generated/SwarmRaftConfig.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmRaftConfig.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmRaftConfig.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnD,qBAAa,eAAgB,SAAQ,oBAcpC;CAAG"}

package/dist/dts/generated/SwarmReplicatedJob.generated.d.ts

@@ -0,0 +1,25 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+declare const SwarmReplicatedJob_base: Schema.Class<SwarmReplicatedJob, {
+    MaxConcurrent: Schema.optionalWith<MobySchemas.UInt64Schemas.$UInt64, {
+        nullable: true;
+    }>;
+    TotalCompletions: Schema.optionalWith<MobySchemas.UInt64Schemas.$UInt64, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    MaxConcurrent: Schema.optionalWith<MobySchemas.UInt64Schemas.$UInt64, {
+        nullable: true;
+    }>;
+    TotalCompletions: Schema.optionalWith<MobySchemas.UInt64Schemas.$UInt64, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly MaxConcurrent?: MobySchemas.UInt64Schemas.UInt64Brand | undefined;
+} & {
+    readonly TotalCompletions?: MobySchemas.UInt64Schemas.UInt64Brand | undefined;
+}, {}, {}>;
+export declare class SwarmReplicatedJob extends SwarmReplicatedJob_base {
+}
+export {};
+//# sourceMappingURL=SwarmReplicatedJob.generated.d.ts.map

package/dist/dts/generated/SwarmReplicatedJob.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmReplicatedJob.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmReplicatedJob.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;AAEnD,qBAAa,kBAAmB,SAAQ,uBAWvC;CAAG"}

package/dist/dts/generated/SwarmReplicatedService.generated.d.ts

@@ -0,0 +1,17 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+declare const SwarmReplicatedService_base: Schema.Class<SwarmReplicatedService, {
+    Replicas: Schema.optionalWith<MobySchemas.UInt64Schemas.$UInt64, {
+        nullable: true;
+    }>;
+}, Schema.Struct.Encoded<{
+    Replicas: Schema.optionalWith<MobySchemas.UInt64Schemas.$UInt64, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly Replicas?: MobySchemas.UInt64Schemas.UInt64Brand | undefined;
+}, {}, {}>;
+export declare class SwarmReplicatedService extends SwarmReplicatedService_base {
+}
+export {};
+//# sourceMappingURL=SwarmReplicatedService.generated.d.ts.map

package/dist/dts/generated/SwarmReplicatedService.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmReplicatedService.generated.d.ts","sourceRoot":"","sources":["../../../src/generated/SwarmReplicatedService.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;;;;;;;;;;;;AAEnD,qBAAa,sBAAuB,SAAQ,2BAU3C;CAAG"}