the-moby-effect 1.51.7 → 1.54.2

package/src/internal/generated/SwarmSecret.generated.ts

@@ -1,10 +1,12 @@
 import * as Schema from "effect/Schema";
-import * as SwarmMeta from "./SwarmMeta.generated.js";
-import * as SwarmSecretSpec from "./SwarmSecretSpec.generated.js";
+
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as SwarmMeta from "./SwarmMeta.generated.ts";
+import * as SwarmSecretSpec from "./SwarmSecretSpec.generated.ts";
 
 export class SwarmSecret extends Schema.Class<SwarmSecret>("SwarmSecret")(
     {
-        ID: Schema.String,
+        ID: MobyIdentifiers.SecretIdentifier,
         ...SwarmMeta.SwarmMeta.fields,
         Spec: Schema.NullOr(SwarmSecretSpec.SwarmSecretSpec),
     },

package/src/internal/generated/SwarmSecretReference.generated.ts

@@ -1,5 +1,6 @@
 import * as Schema from "effect/Schema";
-import * as SwarmSecretReferenceFileTarget from "./SwarmSecretReferenceFileTarget.generated.js";
+
+import * as SwarmSecretReferenceFileTarget from "./SwarmSecretReferenceFileTarget.generated.ts";
 
 export class SwarmSecretReference extends Schema.Class<SwarmSecretReference>("SwarmSecretReference")(
     {

package/src/internal/generated/SwarmSecretReferenceFileTarget.generated.ts

@@ -1,6 +1,7 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmSecretReferenceFileTarget extends Schema.Class<SwarmSecretReferenceFileTarget>(
     "SwarmSecretReferenceFileTarget"
 )(
@@ -8,7 +9,10 @@ export class SwarmSecretReferenceFileTarget extends Schema.Class<SwarmSecretRefe
         Name: Schema.String,
         UID: Schema.String,
         GID: Schema.String,
-        Mode: EffectSchemas.Number.U32,
+        Mode: MobyNumber.NumberFromWireString.check(
+            Schema.isInt(),
+            Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+        ),
     },
     {
         identifier: "SwarmSecretReferenceFileTarget",

package/src/internal/generated/SwarmSecretSpec.generated.ts

@@ -1,13 +1,14 @@
 import * as Schema from "effect/Schema";
-import * as SwarmAnnotations from "./SwarmAnnotations.generated.js";
-import * as SwarmDriver from "./SwarmDriver.generated.js";
+
+import * as SwarmAnnotations from "./SwarmAnnotations.generated.ts";
+import * as SwarmDriver from "./SwarmDriver.generated.ts";
 
 export class SwarmSecretSpec extends Schema.Class<SwarmSecretSpec>("SwarmSecretSpec")(
     {
         ...SwarmAnnotations.SwarmAnnotations.fields,
-        Data: Schema.optionalWith(Schema.Uint8ArrayFromBase64, { nullable: true }),
-        Driver: Schema.optionalWith(SwarmDriver.SwarmDriver, { nullable: true }),
-        Templating: Schema.optionalWith(SwarmDriver.SwarmDriver, { nullable: true }),
+        Data: Schema.optional(Schema.NullOr(Schema.Uint8ArrayFromBase64)),
+        Driver: Schema.optional(Schema.NullOr(SwarmDriver.SwarmDriver)),
+        Templating: Schema.optional(Schema.NullOr(SwarmDriver.SwarmDriver)),
     },
     {
         identifier: "SwarmSecretSpec",

package/src/internal/generated/SwarmService.generated.ts

@@ -1,21 +1,23 @@
 import * as Schema from "effect/Schema";
-import * as SwarmEndpoint from "./SwarmEndpoint.generated.js";
-import * as SwarmJobStatus from "./SwarmJobStatus.generated.js";
-import * as SwarmMeta from "./SwarmMeta.generated.js";
-import * as SwarmServiceSpec from "./SwarmServiceSpec.generated.js";
-import * as SwarmServiceStatus from "./SwarmServiceStatus.generated.js";
-import * as SwarmUpdateStatus from "./SwarmUpdateStatus.generated.js";
+
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as SwarmEndpoint from "./SwarmEndpoint.generated.ts";
+import * as SwarmJobStatus from "./SwarmJobStatus.generated.ts";
+import * as SwarmMeta from "./SwarmMeta.generated.ts";
+import * as SwarmServiceSpec from "./SwarmServiceSpec.generated.ts";
+import * as SwarmServiceStatus from "./SwarmServiceStatus.generated.ts";
+import * as SwarmUpdateStatus from "./SwarmUpdateStatus.generated.ts";
 
 export class SwarmService extends Schema.Class<SwarmService>("SwarmService")(
     {
-        ID: Schema.String,
+        ID: MobyIdentifiers.ServiceIdentifier,
         ...SwarmMeta.SwarmMeta.fields,
-        Spec: Schema.optionalWith(SwarmServiceSpec.SwarmServiceSpec, { nullable: true }),
-        PreviousSpec: Schema.optionalWith(SwarmServiceSpec.SwarmServiceSpec, { nullable: true }),
-        Endpoint: Schema.optionalWith(SwarmEndpoint.SwarmEndpoint, { nullable: true }),
-        UpdateStatus: Schema.optionalWith(SwarmUpdateStatus.SwarmUpdateStatus, { nullable: true }),
-        ServiceStatus: Schema.optionalWith(SwarmServiceStatus.SwarmServiceStatus, { nullable: true }),
-        JobStatus: Schema.optionalWith(SwarmJobStatus.SwarmJobStatus, { nullable: true }),
+        Spec: Schema.optional(Schema.NullOr(SwarmServiceSpec.SwarmServiceSpec)),
+        PreviousSpec: Schema.optional(Schema.NullOr(SwarmServiceSpec.SwarmServiceSpec)),
+        Endpoint: Schema.optional(Schema.NullOr(SwarmEndpoint.SwarmEndpoint)),
+        UpdateStatus: Schema.optional(Schema.NullOr(SwarmUpdateStatus.SwarmUpdateStatus)),
+        ServiceStatus: Schema.optional(Schema.NullOr(SwarmServiceStatus.SwarmServiceStatus)),
+        JobStatus: Schema.optional(Schema.NullOr(SwarmJobStatus.SwarmJobStatus)),
     },
     {
         identifier: "SwarmService",

package/src/internal/generated/SwarmServiceMode.generated.ts

@@ -1,15 +1,16 @@
 import * as Schema from "effect/Schema";
-import * as SwarmGlobalJob from "./SwarmGlobalJob.generated.js";
-import * as SwarmGlobalService from "./SwarmGlobalService.generated.js";
-import * as SwarmReplicatedJob from "./SwarmReplicatedJob.generated.js";
-import * as SwarmReplicatedService from "./SwarmReplicatedService.generated.js";
+
+import * as SwarmGlobalJob from "./SwarmGlobalJob.generated.ts";
+import * as SwarmGlobalService from "./SwarmGlobalService.generated.ts";
+import * as SwarmReplicatedJob from "./SwarmReplicatedJob.generated.ts";
+import * as SwarmReplicatedService from "./SwarmReplicatedService.generated.ts";
 
 export class SwarmServiceMode extends Schema.Class<SwarmServiceMode>("SwarmServiceMode")(
     {
-        Replicated: Schema.optionalWith(SwarmReplicatedService.SwarmReplicatedService, { nullable: true }),
-        Global: Schema.optionalWith(SwarmGlobalService.SwarmGlobalService, { nullable: true }),
-        ReplicatedJob: Schema.optionalWith(SwarmReplicatedJob.SwarmReplicatedJob, { nullable: true }),
-        GlobalJob: Schema.optionalWith(SwarmGlobalJob.SwarmGlobalJob, { nullable: true }),
+        Replicated: Schema.optional(Schema.NullOr(SwarmReplicatedService.SwarmReplicatedService)),
+        Global: Schema.optional(Schema.NullOr(SwarmGlobalService.SwarmGlobalService)),
+        ReplicatedJob: Schema.optional(Schema.NullOr(SwarmReplicatedJob.SwarmReplicatedJob)),
+        GlobalJob: Schema.optional(Schema.NullOr(SwarmGlobalJob.SwarmGlobalJob)),
     },
     {
         identifier: "SwarmServiceMode",

package/src/internal/generated/SwarmServiceSpec.generated.ts

@@ -1,23 +1,23 @@
 import * as Schema from "effect/Schema";
-import * as SwarmAnnotations from "./SwarmAnnotations.generated.js";
-import * as SwarmEndpointSpec from "./SwarmEndpointSpec.generated.js";
-import * as SwarmNetworkAttachmentConfig from "./SwarmNetworkAttachmentConfig.generated.js";
-import * as SwarmServiceMode from "./SwarmServiceMode.generated.js";
-import * as SwarmTaskSpec from "./SwarmTaskSpec.generated.js";
-import * as SwarmUpdateConfig from "./SwarmUpdateConfig.generated.js";
+
+import * as SwarmAnnotations from "./SwarmAnnotations.generated.ts";
+import * as SwarmEndpointSpec from "./SwarmEndpointSpec.generated.ts";
+import * as SwarmNetworkAttachmentConfig from "./SwarmNetworkAttachmentConfig.generated.ts";
+import * as SwarmServiceMode from "./SwarmServiceMode.generated.ts";
+import * as SwarmTaskSpec from "./SwarmTaskSpec.generated.ts";
+import * as SwarmUpdateConfig from "./SwarmUpdateConfig.generated.ts";
 
 export class SwarmServiceSpec extends Schema.Class<SwarmServiceSpec>("SwarmServiceSpec")(
     {
         ...SwarmAnnotations.SwarmAnnotations.fields,
-        TaskTemplate: Schema.optionalWith(SwarmTaskSpec.SwarmTaskSpec, { nullable: true }),
-        Mode: Schema.optionalWith(SwarmServiceMode.SwarmServiceMode, { nullable: true }),
-        UpdateConfig: Schema.optionalWith(SwarmUpdateConfig.SwarmUpdateConfig, { nullable: true }),
-        RollbackConfig: Schema.optionalWith(SwarmUpdateConfig.SwarmUpdateConfig, { nullable: true }),
-        Networks: Schema.optionalWith(
-            Schema.Array(Schema.NullOr(SwarmNetworkAttachmentConfig.SwarmNetworkAttachmentConfig)),
-            { nullable: true }
+        TaskTemplate: Schema.optional(Schema.NullOr(SwarmTaskSpec.SwarmTaskSpec)),
+        Mode: Schema.optional(Schema.NullOr(SwarmServiceMode.SwarmServiceMode)),
+        UpdateConfig: Schema.optional(Schema.NullOr(SwarmUpdateConfig.SwarmUpdateConfig)),
+        RollbackConfig: Schema.optional(Schema.NullOr(SwarmUpdateConfig.SwarmUpdateConfig)),
+        Networks: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(SwarmNetworkAttachmentConfig.SwarmNetworkAttachmentConfig)))
         ),
-        EndpointSpec: Schema.optionalWith(SwarmEndpointSpec.SwarmEndpointSpec, { nullable: true }),
+        EndpointSpec: Schema.optional(Schema.NullOr(SwarmEndpointSpec.SwarmEndpointSpec)),
     },
     {
         identifier: "SwarmServiceSpec",

package/src/internal/generated/SwarmServiceStatus.generated.ts

@@ -1,11 +1,18 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmServiceStatus extends Schema.Class<SwarmServiceStatus>("SwarmServiceStatus")(
     {
-        RunningTasks: EffectSchemas.Number.U64,
-        DesiredTasks: EffectSchemas.Number.U64,
-        CompletedTasks: EffectSchemas.Number.U64,
+        RunningTasks: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        DesiredTasks: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        CompletedTasks: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
     },
     {
         identifier: "SwarmServiceStatus",

package/src/internal/generated/SwarmSpec.generated.ts

@@ -1,21 +1,22 @@
 import * as Schema from "effect/Schema";
-import * as SwarmAnnotations from "./SwarmAnnotations.generated.js";
-import * as SwarmCAConfig from "./SwarmCAConfig.generated.js";
-import * as SwarmDispatcherConfig from "./SwarmDispatcherConfig.generated.js";
-import * as SwarmEncryptionConfig from "./SwarmEncryptionConfig.generated.js";
-import * as SwarmOrchestrationConfig from "./SwarmOrchestrationConfig.generated.js";
-import * as SwarmRaftConfig from "./SwarmRaftConfig.generated.js";
-import * as SwarmTaskDefaults from "./SwarmTaskDefaults.generated.js";
+
+import * as SwarmAnnotations from "./SwarmAnnotations.generated.ts";
+import * as SwarmCAConfig from "./SwarmCAConfig.generated.ts";
+import * as SwarmDispatcherConfig from "./SwarmDispatcherConfig.generated.ts";
+import * as SwarmEncryptionConfig from "./SwarmEncryptionConfig.generated.ts";
+import * as SwarmOrchestrationConfig from "./SwarmOrchestrationConfig.generated.ts";
+import * as SwarmRaftConfig from "./SwarmRaftConfig.generated.ts";
+import * as SwarmTaskDefaults from "./SwarmTaskDefaults.generated.ts";
 
 export class SwarmSpec extends Schema.Class<SwarmSpec>("SwarmSpec")(
     {
         ...SwarmAnnotations.SwarmAnnotations.fields,
-        Orchestration: Schema.optionalWith(SwarmOrchestrationConfig.SwarmOrchestrationConfig, { nullable: true }),
-        Raft: Schema.optionalWith(SwarmRaftConfig.SwarmRaftConfig, { nullable: true }),
-        Dispatcher: Schema.optionalWith(SwarmDispatcherConfig.SwarmDispatcherConfig, { nullable: true }),
-        CAConfig: Schema.optionalWith(SwarmCAConfig.SwarmCAConfig, { nullable: true }),
-        TaskDefaults: Schema.optionalWith(SwarmTaskDefaults.SwarmTaskDefaults, { nullable: true }),
-        EncryptionConfig: Schema.optionalWith(SwarmEncryptionConfig.SwarmEncryptionConfig, { nullable: true }),
+        Orchestration: Schema.optional(Schema.NullOr(SwarmOrchestrationConfig.SwarmOrchestrationConfig)),
+        Raft: Schema.optional(Schema.NullOr(SwarmRaftConfig.SwarmRaftConfig)),
+        Dispatcher: Schema.optional(Schema.NullOr(SwarmDispatcherConfig.SwarmDispatcherConfig)),
+        CAConfig: Schema.optional(Schema.NullOr(SwarmCAConfig.SwarmCAConfig)),
+        TaskDefaults: Schema.optional(Schema.NullOr(SwarmTaskDefaults.SwarmTaskDefaults)),
+        EncryptionConfig: Schema.optional(Schema.NullOr(SwarmEncryptionConfig.SwarmEncryptionConfig)),
     },
     {
         identifier: "SwarmSpec",

package/src/internal/generated/SwarmSwarm.generated.ts

@@ -1,6 +1,7 @@
 import * as Schema from "effect/Schema";
-import * as SwarmClusterInfo from "./SwarmClusterInfo.generated.js";
-import * as SwarmJoinTokens from "./SwarmJoinTokens.generated.js";
+
+import * as SwarmClusterInfo from "./SwarmClusterInfo.generated.ts";
+import * as SwarmJoinTokens from "./SwarmJoinTokens.generated.ts";
 
 export class SwarmSwarm extends Schema.Class<SwarmSwarm>("SwarmSwarm")(
     {

package/src/internal/generated/SwarmTLSInfo.generated.ts

@@ -3,8 +3,8 @@ import * as Schema from "effect/Schema";
 export class SwarmTLSInfo extends Schema.Class<SwarmTLSInfo>("SwarmTLSInfo")(
     {
         TrustRoot: Schema.optional(Schema.String),
-        CertIssuerSubject: Schema.optionalWith(Schema.StringFromBase64, { nullable: true }),
-        CertIssuerPublicKey: Schema.optionalWith(Schema.StringFromBase64, { nullable: true }),
+        CertIssuerSubject: Schema.optional(Schema.NullOr(Schema.StringFromBase64)),
+        CertIssuerPublicKey: Schema.optional(Schema.NullOr(Schema.StringFromBase64)),
     },
     {
         identifier: "SwarmTLSInfo",

package/src/internal/generated/SwarmTask.generated.ts

@@ -1,26 +1,32 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as SwarmAnnotations from "./SwarmAnnotations.generated.js";
-import * as SwarmGenericResource from "./SwarmGenericResource.generated.js";
-import * as SwarmMeta from "./SwarmMeta.generated.js";
-import * as SwarmNetworkAttachment from "./SwarmNetworkAttachment.generated.js";
-import * as SwarmTaskSpec from "./SwarmTaskSpec.generated.js";
-import * as SwarmTaskStatus from "./SwarmTaskStatus.generated.js";
-import * as SwarmVersion from "./SwarmVersion.generated.js";
-import * as SwarmVolumeAttachment from "./SwarmVolumeAttachment.generated.js";
+
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as MobyNumber from "../schemas/number.ts";
+import * as SwarmAnnotations from "./SwarmAnnotations.generated.ts";
+import * as SwarmGenericResource from "./SwarmGenericResource.generated.ts";
+import * as SwarmMeta from "./SwarmMeta.generated.ts";
+import * as SwarmNetworkAttachment from "./SwarmNetworkAttachment.generated.ts";
+import * as SwarmTaskSpec from "./SwarmTaskSpec.generated.ts";
+import * as SwarmTaskStatus from "./SwarmTaskStatus.generated.ts";
+import * as SwarmVersion from "./SwarmVersion.generated.ts";
+import * as SwarmVolumeAttachment from "./SwarmVolumeAttachment.generated.ts";
 
 export class SwarmTask extends Schema.Class<SwarmTask>("SwarmTask")(
     {
-        ID: Schema.String,
+        ID: MobyIdentifiers.TaskIdentifier,
         ...SwarmMeta.SwarmMeta.fields,
         ...SwarmAnnotations.SwarmAnnotations.fields,
-        Spec: Schema.optionalWith(SwarmTaskSpec.SwarmTaskSpec, { nullable: true }),
-        ServiceID: Schema.optional(Schema.String),
-        Slot: Schema.optional(EffectSchemas.Number.I64),
-        NodeID: Schema.optional(Schema.String),
-        Status: Schema.optionalWith(SwarmTaskStatus.SwarmTaskStatus, { nullable: true }),
+        Spec: Schema.optional(Schema.NullOr(SwarmTaskSpec.SwarmTaskSpec)),
+        ServiceID: Schema.optional(MobyIdentifiers.ServiceIdentifier),
+        Slot: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        NodeID: Schema.optional(MobyIdentifiers.NodeIdentifier),
+        Status: Schema.optional(Schema.NullOr(SwarmTaskStatus.SwarmTaskStatus)),
         DesiredState: Schema.optional(
-            Schema.Literal(
+            Schema.Literals([
                 "new",
                 "allocated",
                 "pending",
@@ -35,17 +41,16 @@ export class SwarmTask extends Schema.Class<SwarmTask>("SwarmTask")(
                 "failed",
                 "rejected",
                 "remove",
-                "orphaned"
-            )
+                "orphaned",
+            ])
+        ),
+        NetworksAttachments: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(SwarmNetworkAttachment.SwarmNetworkAttachment)))
         ),
-        NetworksAttachments: Schema.optionalWith(
-            Schema.Array(Schema.NullOr(SwarmNetworkAttachment.SwarmNetworkAttachment)),
-            { nullable: true }
+        GenericResources: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(SwarmGenericResource.SwarmGenericResource)))
         ),
-        GenericResources: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmGenericResource.SwarmGenericResource)), {
-            nullable: true,
-        }),
-        JobIteration: Schema.optionalWith(SwarmVersion.SwarmVersion, { nullable: true }),
+        JobIteration: Schema.optional(Schema.NullOr(SwarmVersion.SwarmVersion)),
         Volumes: Schema.NullOr(Schema.Array(Schema.NullOr(SwarmVolumeAttachment.SwarmVolumeAttachment))),
     },
     {

package/src/internal/generated/SwarmTaskDefaults.generated.ts

@@ -1,9 +1,10 @@
 import * as Schema from "effect/Schema";
-import * as SwarmDriver from "./SwarmDriver.generated.js";
+
+import * as SwarmDriver from "./SwarmDriver.generated.ts";
 
 export class SwarmTaskDefaults extends Schema.Class<SwarmTaskDefaults>("SwarmTaskDefaults")(
     {
-        LogDriver: Schema.optionalWith(SwarmDriver.SwarmDriver, { nullable: true }),
+        LogDriver: Schema.optional(Schema.NullOr(SwarmDriver.SwarmDriver)),
     },
     {
         identifier: "SwarmTaskDefaults",

package/src/internal/generated/SwarmTaskSpec.generated.ts

@@ -1,31 +1,31 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as RuntimePluginSpec from "./RuntimePluginSpec.generated.js";
-import * as SwarmContainerSpec from "./SwarmContainerSpec.generated.js";
-import * as SwarmDriver from "./SwarmDriver.generated.js";
-import * as SwarmNetworkAttachmentConfig from "./SwarmNetworkAttachmentConfig.generated.js";
-import * as SwarmNetworkAttachmentSpec from "./SwarmNetworkAttachmentSpec.generated.js";
-import * as SwarmPlacement from "./SwarmPlacement.generated.js";
-import * as SwarmResourceRequirements from "./SwarmResourceRequirements.generated.js";
-import * as SwarmRestartPolicy from "./SwarmRestartPolicy.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as RuntimePluginSpec from "./RuntimePluginSpec.generated.ts";
+import * as SwarmContainerSpec from "./SwarmContainerSpec.generated.ts";
+import * as SwarmDriver from "./SwarmDriver.generated.ts";
+import * as SwarmNetworkAttachmentConfig from "./SwarmNetworkAttachmentConfig.generated.ts";
+import * as SwarmNetworkAttachmentSpec from "./SwarmNetworkAttachmentSpec.generated.ts";
+import * as SwarmPlacement from "./SwarmPlacement.generated.ts";
+import * as SwarmResourceRequirements from "./SwarmResourceRequirements.generated.ts";
+import * as SwarmRestartPolicy from "./SwarmRestartPolicy.generated.ts";
 
 export class SwarmTaskSpec extends Schema.Class<SwarmTaskSpec>("SwarmTaskSpec")(
     {
-        ContainerSpec: Schema.optionalWith(SwarmContainerSpec.SwarmContainerSpec, { nullable: true }),
-        PluginSpec: Schema.optionalWith(RuntimePluginSpec.RuntimePluginSpec, { nullable: true }),
-        NetworkAttachmentSpec: Schema.optionalWith(SwarmNetworkAttachmentSpec.SwarmNetworkAttachmentSpec, {
-            nullable: true,
-        }),
-        Resources: Schema.optionalWith(SwarmResourceRequirements.SwarmResourceRequirements, { nullable: true }),
-        RestartPolicy: Schema.optionalWith(SwarmRestartPolicy.SwarmRestartPolicy, { nullable: true }),
-        Placement: Schema.optionalWith(SwarmPlacement.SwarmPlacement, { nullable: true }),
-        Networks: Schema.optionalWith(
-            Schema.Array(Schema.NullOr(SwarmNetworkAttachmentConfig.SwarmNetworkAttachmentConfig)),
-            { nullable: true }
+        ContainerSpec: Schema.optional(Schema.NullOr(SwarmContainerSpec.SwarmContainerSpec)),
+        PluginSpec: Schema.optional(Schema.NullOr(RuntimePluginSpec.RuntimePluginSpec)),
+        NetworkAttachmentSpec: Schema.optional(Schema.NullOr(SwarmNetworkAttachmentSpec.SwarmNetworkAttachmentSpec)),
+        Resources: Schema.optional(Schema.NullOr(SwarmResourceRequirements.SwarmResourceRequirements)),
+        RestartPolicy: Schema.optional(Schema.NullOr(SwarmRestartPolicy.SwarmRestartPolicy)),
+        Placement: Schema.optional(Schema.NullOr(SwarmPlacement.SwarmPlacement)),
+        Networks: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(SwarmNetworkAttachmentConfig.SwarmNetworkAttachmentConfig)))
+        ),
+        LogDriver: Schema.optional(Schema.NullOr(SwarmDriver.SwarmDriver)),
+        ForceUpdate: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
         ),
-        LogDriver: Schema.optionalWith(SwarmDriver.SwarmDriver, { nullable: true }),
-        ForceUpdate: EffectSchemas.Number.U64,
-        Runtime: Schema.optional(Schema.Literal("container", "plugin", "attachment")),
+        Runtime: Schema.optional(Schema.Literals(["container", "plugin", "attachment"])),
     },
     {
         identifier: "SwarmTaskSpec",

package/src/internal/generated/SwarmTaskStatus.generated.ts

@@ -1,12 +1,13 @@
 import * as Schema from "effect/Schema";
-import * as SwarmContainerStatus from "./SwarmContainerStatus.generated.js";
-import * as SwarmPortStatus from "./SwarmPortStatus.generated.js";
+
+import * as SwarmContainerStatus from "./SwarmContainerStatus.generated.ts";
+import * as SwarmPortStatus from "./SwarmPortStatus.generated.ts";
 
 export class SwarmTaskStatus extends Schema.Class<SwarmTaskStatus>("SwarmTaskStatus")(
     {
-        Timestamp: Schema.optionalWith(Schema.DateFromString, { nullable: true }),
+        Timestamp: Schema.optional(Schema.NullOr(Schema.DateFromString)),
         State: Schema.optional(
-            Schema.Literal(
+            Schema.Literals([
                 "new",
                 "allocated",
                 "pending",
@@ -21,13 +22,13 @@ export class SwarmTaskStatus extends Schema.Class<SwarmTaskStatus>("SwarmTaskSta
                 "failed",
                 "rejected",
                 "remove",
-                "orphaned"
-            )
+                "orphaned",
+            ])
         ),
         Message: Schema.optional(Schema.String),
         Err: Schema.optional(Schema.String),
-        ContainerStatus: Schema.optionalWith(SwarmContainerStatus.SwarmContainerStatus, { nullable: true }),
-        PortStatus: Schema.optionalWith(SwarmPortStatus.SwarmPortStatus, { nullable: true }),
+        ContainerStatus: Schema.optional(Schema.NullOr(SwarmContainerStatus.SwarmContainerStatus)),
+        PortStatus: Schema.optional(Schema.NullOr(SwarmPortStatus.SwarmPortStatus)),
     },
     {
         identifier: "SwarmTaskStatus",

package/src/internal/generated/SwarmTopology.generated.ts

@@ -2,7 +2,7 @@ import * as Schema from "effect/Schema";
 
 export class SwarmTopology extends Schema.Class<SwarmTopology>("SwarmTopology")(
     {
-        Segments: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
+        Segments: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
     },
     {
         identifier: "SwarmTopology",

package/src/internal/generated/SwarmUpdateConfig.generated.ts

@@ -1,13 +1,24 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmUpdateConfig extends Schema.Class<SwarmUpdateConfig>("SwarmUpdateConfig")(
     {
-        Parallelism: EffectSchemas.Number.U64,
-        Delay: Schema.optional(EffectSchemas.Number.I64),
+        Parallelism: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        Delay: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
         FailureAction: Schema.optional(Schema.String),
-        Monitor: Schema.optional(EffectSchemas.Number.I64),
-        MaxFailureRatio: Schema.Number,
+        Monitor: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        MaxFailureRatio: MobyNumber.NumberFromWireString,
         Order: Schema.String,
     },
     {

package/src/internal/generated/SwarmUpdateStatus.generated.ts

@@ -3,17 +3,17 @@ import * as Schema from "effect/Schema";
 export class SwarmUpdateStatus extends Schema.Class<SwarmUpdateStatus>("SwarmUpdateStatus")(
     {
         State: Schema.optional(
-            Schema.Literal(
+            Schema.Literals([
                 "updating",
                 "paused",
                 "completed",
                 "rollback_started",
                 "rollback_paused",
-                "rollback_completed"
-            )
+                "rollback_completed",
+            ])
         ),
-        StartedAt: Schema.optionalWith(Schema.DateFromString, { nullable: true }),
-        CompletedAt: Schema.optionalWith(Schema.DateFromString, { nullable: true }),
+        StartedAt: Schema.optional(Schema.NullOr(Schema.DateFromString)),
+        CompletedAt: Schema.optional(Schema.NullOr(Schema.DateFromString)),
         Message: Schema.optional(Schema.String),
     },
     {

package/src/internal/generated/SwarmVersion.generated.ts

@@ -1,9 +1,12 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmVersion extends Schema.Class<SwarmVersion>("SwarmVersion")(
     {
-        Index: Schema.optional(EffectSchemas.Number.U64),
+        Index: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
     },
     {
         identifier: "SwarmVersion",

package/src/internal/generated/SystemContainerdInfo.generated.ts

@@ -1,5 +1,6 @@
 import * as Schema from "effect/Schema";
-import * as SystemContainerdNamespaces from "./SystemContainerdNamespaces.generated.js";
+
+import * as SystemContainerdNamespaces from "./SystemContainerdNamespaces.generated.ts";
 
 export class SystemContainerdInfo extends Schema.Class<SystemContainerdInfo>("SystemContainerdInfo")(
     {

package/src/internal/generated/SystemFirewallInfo.generated.ts

@@ -3,9 +3,9 @@ import * as Schema from "effect/Schema";
 export class SystemFirewallInfo extends Schema.Class<SystemFirewallInfo>("SystemFirewallInfo")(
     {
         Driver: Schema.String,
-        Info: Schema.optionalWith(Schema.Array(Schema.Array(Schema.String).pipe(Schema.itemsCount(2))), {
-            nullable: true,
-        }),
+        Info: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.Array(Schema.String).check(Schema.isLengthBetween(2, 2))))
+        ),
     },
     {
         identifier: "SystemFirewallInfo",