the-moby-effect 1.51.6 → 1.54.1

package/src/internal/generated/SwarmJobStatus.generated.ts

@@ -1,10 +1,11 @@
 import * as Schema from "effect/Schema";
-import * as SwarmVersion from "./SwarmVersion.generated.js";
+
+import * as SwarmVersion from "./SwarmVersion.generated.ts";
 
 export class SwarmJobStatus extends Schema.Class<SwarmJobStatus>("SwarmJobStatus")(
     {
         JobIteration: Schema.NullOr(SwarmVersion.SwarmVersion),
-        LastExecution: Schema.optionalWith(Schema.DateFromString, { nullable: true }),
+        LastExecution: Schema.optional(Schema.NullOr(Schema.DateFromString)),
     },
     {
         identifier: "SwarmJobStatus",

package/src/internal/generated/SwarmJoinRequest.generated.ts

@@ -7,7 +7,7 @@ export class SwarmJoinRequest extends Schema.Class<SwarmJoinRequest>("SwarmJoinR
         DataPathAddr: Schema.String,
         RemoteAddrs: Schema.NullOr(Schema.Array(Schema.String)),
         JoinToken: Schema.String,
-        Availability: Schema.Literal("active", "pause", "drain"),
+        Availability: Schema.Literals(["active", "pause", "drain"]),
     },
     {
         identifier: "SwarmJoinRequest",

package/src/internal/generated/SwarmLimit.generated.ts

@@ -1,11 +1,24 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmLimit extends Schema.Class<SwarmLimit>("SwarmLimit")(
     {
-        NanoCPUs: Schema.optional(EffectSchemas.Number.I64),
-        MemoryBytes: Schema.optional(EffectSchemas.Number.I64),
-        Pids: Schema.optional(EffectSchemas.Number.I64),
+        NanoCPUs: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        MemoryBytes: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        Pids: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
     },
     {
         identifier: "SwarmLimit",

package/src/internal/generated/SwarmManagerStatus.generated.ts

@@ -3,7 +3,7 @@ import * as Schema from "effect/Schema";
 export class SwarmManagerStatus extends Schema.Class<SwarmManagerStatus>("SwarmManagerStatus")(
     {
         Leader: Schema.optional(Schema.Boolean),
-        Reachability: Schema.optional(Schema.Literal("unknown", "unreachable", "reachable")),
+        Reachability: Schema.optional(Schema.Literals(["unknown", "unreachable", "reachable"])),
         Addr: Schema.optional(Schema.String),
     },
     {

package/src/internal/generated/SwarmMeta.generated.ts

@@ -1,11 +1,12 @@
 import * as Schema from "effect/Schema";
-import * as SwarmVersion from "./SwarmVersion.generated.js";
+
+import * as SwarmVersion from "./SwarmVersion.generated.ts";
 
 export class SwarmMeta extends Schema.Class<SwarmMeta>("SwarmMeta")(
     {
-        Version: Schema.optionalWith(SwarmVersion.SwarmVersion, { nullable: true }),
-        CreatedAt: Schema.optionalWith(Schema.DateFromString, { nullable: true }),
-        UpdatedAt: Schema.optionalWith(Schema.DateFromString, { nullable: true }),
+        Version: Schema.optional(Schema.NullOr(SwarmVersion.SwarmVersion)),
+        CreatedAt: Schema.optional(Schema.NullOr(Schema.DateFromString)),
+        UpdatedAt: Schema.optional(Schema.NullOr(Schema.DateFromString)),
     },
     {
         identifier: "SwarmMeta",

package/src/internal/generated/SwarmNetwork.generated.ts

@@ -1,16 +1,18 @@
 import * as Schema from "effect/Schema";
-import * as SwarmDriver from "./SwarmDriver.generated.js";
-import * as SwarmIPAMOptions from "./SwarmIPAMOptions.generated.js";
-import * as SwarmMeta from "./SwarmMeta.generated.js";
-import * as SwarmNetworkSpec from "./SwarmNetworkSpec.generated.js";
+
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as SwarmDriver from "./SwarmDriver.generated.ts";
+import * as SwarmIPAMOptions from "./SwarmIPAMOptions.generated.ts";
+import * as SwarmMeta from "./SwarmMeta.generated.ts";
+import * as SwarmNetworkSpec from "./SwarmNetworkSpec.generated.ts";
 
 export class SwarmNetwork extends Schema.Class<SwarmNetwork>("SwarmNetwork")(
     {
-        ID: Schema.String,
+        ID: MobyIdentifiers.NetworkIdentifier,
         ...SwarmMeta.SwarmMeta.fields,
-        Spec: Schema.optionalWith(SwarmNetworkSpec.SwarmNetworkSpec, { nullable: true }),
-        DriverState: Schema.optionalWith(SwarmDriver.SwarmDriver, { nullable: true }),
-        IPAMOptions: Schema.optionalWith(SwarmIPAMOptions.SwarmIPAMOptions, { nullable: true }),
+        Spec: Schema.optional(Schema.NullOr(SwarmNetworkSpec.SwarmNetworkSpec)),
+        DriverState: Schema.optional(Schema.NullOr(SwarmDriver.SwarmDriver)),
+        IPAMOptions: Schema.optional(Schema.NullOr(SwarmIPAMOptions.SwarmIPAMOptions)),
     },
     {
         identifier: "SwarmNetwork",

package/src/internal/generated/SwarmNetworkAttachment.generated.ts

@@ -1,10 +1,11 @@
 import * as Schema from "effect/Schema";
-import * as SwarmNetwork from "./SwarmNetwork.generated.js";
+
+import * as SwarmNetwork from "./SwarmNetwork.generated.ts";
 
 export class SwarmNetworkAttachment extends Schema.Class<SwarmNetworkAttachment>("SwarmNetworkAttachment")(
     {
-        Network: Schema.optionalWith(SwarmNetwork.SwarmNetwork, { nullable: true }),
-        Addresses: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        Network: Schema.optional(Schema.NullOr(SwarmNetwork.SwarmNetwork)),
+        Addresses: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
     },
     {
         identifier: "SwarmNetworkAttachment",

package/src/internal/generated/SwarmNetworkAttachmentConfig.generated.ts

@@ -5,10 +5,8 @@ export class SwarmNetworkAttachmentConfig extends Schema.Class<SwarmNetworkAttac
 )(
     {
         Target: Schema.optional(Schema.String),
-        Aliases: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        DriverOpts: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), {
-            nullable: true,
-        }),
+        Aliases: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        DriverOpts: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
     },
     {
         identifier: "SwarmNetworkAttachmentConfig",

package/src/internal/generated/SwarmNetworkAttachmentSpec.generated.ts

@@ -1,8 +1,10 @@
 import * as Schema from "effect/Schema";
 
+import * as MobyIdentifiers from "../schemas/id.ts";
+
 export class SwarmNetworkAttachmentSpec extends Schema.Class<SwarmNetworkAttachmentSpec>("SwarmNetworkAttachmentSpec")(
     {
-        ContainerID: Schema.String,
+        ContainerID: MobyIdentifiers.ContainerIdentifier,
     },
     {
         identifier: "SwarmNetworkAttachmentSpec",

package/src/internal/generated/SwarmNetworkSpec.generated.ts

@@ -1,19 +1,20 @@
 import * as Schema from "effect/Schema";
-import * as NetworkConfigReference from "./NetworkConfigReference.generated.js";
-import * as SwarmAnnotations from "./SwarmAnnotations.generated.js";
-import * as SwarmDriver from "./SwarmDriver.generated.js";
-import * as SwarmIPAMOptions from "./SwarmIPAMOptions.generated.js";
+
+import * as NetworkConfigReference from "./NetworkConfigReference.generated.ts";
+import * as SwarmAnnotations from "./SwarmAnnotations.generated.ts";
+import * as SwarmDriver from "./SwarmDriver.generated.ts";
+import * as SwarmIPAMOptions from "./SwarmIPAMOptions.generated.ts";
 
 export class SwarmNetworkSpec extends Schema.Class<SwarmNetworkSpec>("SwarmNetworkSpec")(
     {
         ...SwarmAnnotations.SwarmAnnotations.fields,
-        DriverConfiguration: Schema.optionalWith(SwarmDriver.SwarmDriver, { nullable: true }),
+        DriverConfiguration: Schema.optional(Schema.NullOr(SwarmDriver.SwarmDriver)),
         IPv6Enabled: Schema.optional(Schema.Boolean),
         Internal: Schema.optional(Schema.Boolean),
         Attachable: Schema.optional(Schema.Boolean),
         Ingress: Schema.optional(Schema.Boolean),
-        IPAMOptions: Schema.optionalWith(SwarmIPAMOptions.SwarmIPAMOptions, { nullable: true }),
-        ConfigFrom: Schema.optionalWith(NetworkConfigReference.NetworkConfigReference, { nullable: true }),
+        IPAMOptions: Schema.optional(Schema.NullOr(SwarmIPAMOptions.SwarmIPAMOptions)),
+        ConfigFrom: Schema.optional(Schema.NullOr(NetworkConfigReference.NetworkConfigReference)),
         Scope: Schema.optional(Schema.String),
     },
     {

package/src/internal/generated/SwarmNode.generated.ts

@@ -1,18 +1,20 @@
 import * as Schema from "effect/Schema";
-import * as SwarmManagerStatus from "./SwarmManagerStatus.generated.js";
-import * as SwarmMeta from "./SwarmMeta.generated.js";
-import * as SwarmNodeDescription from "./SwarmNodeDescription.generated.js";
-import * as SwarmNodeSpec from "./SwarmNodeSpec.generated.js";
-import * as SwarmNodeStatus from "./SwarmNodeStatus.generated.js";
+
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as SwarmManagerStatus from "./SwarmManagerStatus.generated.ts";
+import * as SwarmMeta from "./SwarmMeta.generated.ts";
+import * as SwarmNodeDescription from "./SwarmNodeDescription.generated.ts";
+import * as SwarmNodeSpec from "./SwarmNodeSpec.generated.ts";
+import * as SwarmNodeStatus from "./SwarmNodeStatus.generated.ts";
 
 export class SwarmNode extends Schema.Class<SwarmNode>("SwarmNode")(
     {
-        ID: Schema.String,
+        ID: MobyIdentifiers.NodeIdentifier,
         ...SwarmMeta.SwarmMeta.fields,
-        Spec: Schema.optionalWith(SwarmNodeSpec.SwarmNodeSpec, { nullable: true }),
-        Description: Schema.optionalWith(SwarmNodeDescription.SwarmNodeDescription, { nullable: true }),
-        Status: Schema.optionalWith(SwarmNodeStatus.SwarmNodeStatus, { nullable: true }),
-        ManagerStatus: Schema.optionalWith(SwarmManagerStatus.SwarmManagerStatus, { nullable: true }),
+        Spec: Schema.optional(Schema.NullOr(SwarmNodeSpec.SwarmNodeSpec)),
+        Description: Schema.optional(Schema.NullOr(SwarmNodeDescription.SwarmNodeDescription)),
+        Status: Schema.optional(Schema.NullOr(SwarmNodeStatus.SwarmNodeStatus)),
+        ManagerStatus: Schema.optional(Schema.NullOr(SwarmManagerStatus.SwarmManagerStatus)),
     },
     {
         identifier: "SwarmNode",

package/src/internal/generated/SwarmNodeCSIInfo.generated.ts

@@ -1,13 +1,19 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as SwarmTopology from "./SwarmTopology.generated.js";
+
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as MobyNumber from "../schemas/number.ts";
+import * as SwarmTopology from "./SwarmTopology.generated.ts";
 
 export class SwarmNodeCSIInfo extends Schema.Class<SwarmNodeCSIInfo>("SwarmNodeCSIInfo")(
     {
         PluginName: Schema.optional(Schema.String),
-        NodeID: Schema.optional(Schema.String),
-        MaxVolumesPerNode: Schema.optional(EffectSchemas.Number.I64),
-        AccessibleTopology: Schema.optionalWith(SwarmTopology.SwarmTopology, { nullable: true }),
+        NodeID: Schema.optional(MobyIdentifiers.NodeIdentifier),
+        MaxVolumesPerNode: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        AccessibleTopology: Schema.optional(Schema.NullOr(SwarmTopology.SwarmTopology)),
     },
     {
         identifier: "SwarmNodeCSIInfo",

package/src/internal/generated/SwarmNodeDescription.generated.ts

@@ -1,20 +1,19 @@
 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";
+
+import * as SwarmEngineDescription from "./SwarmEngineDescription.generated.ts";
+import * as SwarmNodeCSIInfo from "./SwarmNodeCSIInfo.generated.ts";
+import * as SwarmPlatform from "./SwarmPlatform.generated.ts";
+import * as SwarmResources from "./SwarmResources.generated.ts";
+import * as SwarmTLSInfo from "./SwarmTLSInfo.generated.ts";
 
 export class SwarmNodeDescription extends Schema.Class<SwarmNodeDescription>("SwarmNodeDescription")(
     {
         Hostname: Schema.optional(Schema.String),
-        Platform: Schema.optionalWith(SwarmPlatform.SwarmPlatform, { nullable: true }),
-        Resources: Schema.optionalWith(SwarmResources.SwarmResources, { nullable: true }),
-        Engine: Schema.optionalWith(SwarmEngineDescription.SwarmEngineDescription, { nullable: true }),
-        TLSInfo: Schema.optionalWith(SwarmTLSInfo.SwarmTLSInfo, { nullable: true }),
-        CSIInfo: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmNodeCSIInfo.SwarmNodeCSIInfo)), {
-            nullable: true,
-        }),
+        Platform: Schema.optional(Schema.NullOr(SwarmPlatform.SwarmPlatform)),
+        Resources: Schema.optional(Schema.NullOr(SwarmResources.SwarmResources)),
+        Engine: Schema.optional(Schema.NullOr(SwarmEngineDescription.SwarmEngineDescription)),
+        TLSInfo: Schema.optional(Schema.NullOr(SwarmTLSInfo.SwarmTLSInfo)),
+        CSIInfo: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(SwarmNodeCSIInfo.SwarmNodeCSIInfo)))),
     },
     {
         identifier: "SwarmNodeDescription",

package/src/internal/generated/SwarmNodeSpec.generated.ts

@@ -1,11 +1,12 @@
 import * as Schema from "effect/Schema";
-import * as SwarmAnnotations from "./SwarmAnnotations.generated.js";
+
+import * as SwarmAnnotations from "./SwarmAnnotations.generated.ts";
 
 export class SwarmNodeSpec extends Schema.Class<SwarmNodeSpec>("SwarmNodeSpec")(
     {
         ...SwarmAnnotations.SwarmAnnotations.fields,
-        Role: Schema.optional(Schema.Literal("worker", "manager")),
-        Availability: Schema.optional(Schema.Literal("active", "pause", "drain")),
+        Role: Schema.optional(Schema.Literals(["worker", "manager"])),
+        Availability: Schema.optional(Schema.Literals(["active", "pause", "drain"])),
     },
     {
         identifier: "SwarmNodeSpec",

package/src/internal/generated/SwarmNodeStatus.generated.ts

@@ -2,7 +2,7 @@ import * as Schema from "effect/Schema";
 
 export class SwarmNodeStatus extends Schema.Class<SwarmNodeStatus>("SwarmNodeStatus")(
     {
-        State: Schema.optional(Schema.Literal("unknown", "down", "ready", "disconnected")),
+        State: Schema.optional(Schema.Literals(["unknown", "down", "ready", "disconnected"])),
         Message: Schema.optional(Schema.String),
         Addr: Schema.optional(Schema.String),
     },

package/src/internal/generated/SwarmOrchestrationConfig.generated.ts

@@ -1,9 +1,16 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmOrchestrationConfig extends Schema.Class<SwarmOrchestrationConfig>("SwarmOrchestrationConfig")(
     {
-        TaskHistoryRetentionLimit: Schema.optionalWith(EffectSchemas.Number.I64, { nullable: true }),
+        TaskHistoryRetentionLimit: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(
+                    Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+                )
+            )
+        ),
     },
     {
         identifier: "SwarmOrchestrationConfig",

package/src/internal/generated/SwarmPeer.generated.ts

@@ -1,8 +1,10 @@
 import * as Schema from "effect/Schema";
 
+import * as MobyIdentifiers from "../schemas/id.ts";
+
 export class SwarmPeer extends Schema.Class<SwarmPeer>("SwarmPeer")(
     {
-        NodeID: Schema.String,
+        NodeID: MobyIdentifiers.NodeIdentifier,
         Addr: Schema.String,
     },
     {

package/src/internal/generated/SwarmPlacement.generated.ts

@@ -1,17 +1,19 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as SwarmPlacementPreference from "./SwarmPlacementPreference.generated.js";
-import * as SwarmPlatform from "./SwarmPlatform.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as SwarmPlacementPreference from "./SwarmPlacementPreference.generated.ts";
+import * as SwarmPlatform from "./SwarmPlatform.generated.ts";
 
 export class SwarmPlacement extends Schema.Class<SwarmPlacement>("SwarmPlacement")(
     {
-        Constraints: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Preferences: Schema.optionalWith(
-            Schema.Array(Schema.NullOr(SwarmPlacementPreference.SwarmPlacementPreference)),
-            { nullable: true }
+        Constraints: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Preferences: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(SwarmPlacementPreference.SwarmPlacementPreference)))
+        ),
+        MaxReplicas: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
         ),
-        MaxReplicas: Schema.optional(EffectSchemas.Number.U64),
-        Platforms: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmPlatform.SwarmPlatform)), { nullable: true }),
+        Platforms: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(SwarmPlatform.SwarmPlatform)))),
     },
     {
         identifier: "SwarmPlacement",

package/src/internal/generated/SwarmPlacementPreference.generated.ts

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

package/src/internal/generated/SwarmPortConfig.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 SwarmPortConfig extends Schema.Class<SwarmPortConfig>("SwarmPortConfig")(
     {
         Name: Schema.optional(Schema.String),
-        Protocol: Schema.optional(Schema.Literal("tcp", "udp", "sctp")),
-        TargetPort: Schema.optional(EffectSchemas.Number.U32),
-        PublishedPort: Schema.optional(EffectSchemas.Number.U32),
-        PublishMode: Schema.optional(Schema.Literal("ingress", "host")),
+        Protocol: Schema.optional(Schema.Literals(["tcp", "udp", "sctp"])),
+        TargetPort: Schema.optional(
+            MobyNumber.NumberFromWireString.check(
+                Schema.isInt(),
+                Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+            )
+        ),
+        PublishedPort: Schema.optional(
+            MobyNumber.NumberFromWireString.check(
+                Schema.isInt(),
+                Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+            )
+        ),
+        PublishMode: Schema.optional(Schema.Literals(["ingress", "host"])),
     },
     {
         identifier: "SwarmPortConfig",

package/src/internal/generated/SwarmPortStatus.generated.ts

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

package/src/internal/generated/SwarmPrivileges.generated.ts

@@ -1,15 +1,16 @@
 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";
+
+import * as SwarmAppArmorOpts from "./SwarmAppArmorOpts.generated.ts";
+import * as SwarmCredentialSpec from "./SwarmCredentialSpec.generated.ts";
+import * as SwarmSeccompOpts from "./SwarmSeccompOpts.generated.ts";
+import * as SwarmSELinuxContext from "./SwarmSELinuxContext.generated.ts";
 
 export class SwarmPrivileges extends Schema.Class<SwarmPrivileges>("SwarmPrivileges")(
     {
         CredentialSpec: Schema.NullOr(SwarmCredentialSpec.SwarmCredentialSpec),
         SELinuxContext: Schema.NullOr(SwarmSELinuxContext.SwarmSELinuxContext),
-        Seccomp: Schema.optionalWith(SwarmSeccompOpts.SwarmSeccompOpts, { nullable: true }),
-        AppArmor: Schema.optionalWith(SwarmAppArmorOpts.SwarmAppArmorOpts, { nullable: true }),
+        Seccomp: Schema.optional(Schema.NullOr(SwarmSeccompOpts.SwarmSeccompOpts)),
+        AppArmor: Schema.optional(Schema.NullOr(SwarmAppArmorOpts.SwarmAppArmorOpts)),
         NoNewPrivileges: Schema.Boolean,
     },
     {

package/src/internal/generated/SwarmRaftConfig.generated.ts

@@ -1,13 +1,26 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmRaftConfig extends Schema.Class<SwarmRaftConfig>("SwarmRaftConfig")(
     {
-        SnapshotInterval: Schema.optional(EffectSchemas.Number.U64),
-        KeepOldSnapshots: Schema.optionalWith(EffectSchemas.Number.U64, { nullable: true }),
-        LogEntriesForSlowFollowers: Schema.optional(EffectSchemas.Number.U64),
-        ElectionTick: EffectSchemas.Number.I64,
-        HeartbeatTick: EffectSchemas.Number.I64,
+        SnapshotInterval: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
+        KeepOldSnapshots: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+            )
+        ),
+        LogEntriesForSlowFollowers: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
+        ElectionTick: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        HeartbeatTick: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
     },
     {
         identifier: "SwarmRaftConfig",

package/src/internal/generated/SwarmReplicatedJob.generated.ts

@@ -1,10 +1,19 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmReplicatedJob extends Schema.Class<SwarmReplicatedJob>("SwarmReplicatedJob")(
     {
-        MaxConcurrent: Schema.optionalWith(EffectSchemas.Number.U64, { nullable: true }),
-        TotalCompletions: Schema.optionalWith(EffectSchemas.Number.U64, { nullable: true }),
+        MaxConcurrent: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+            )
+        ),
+        TotalCompletions: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+            )
+        ),
     },
     {
         identifier: "SwarmReplicatedJob",

package/src/internal/generated/SwarmReplicatedService.generated.ts

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

package/src/internal/generated/SwarmResourceRequirements.generated.ts

@@ -1,11 +1,12 @@
 import * as Schema from "effect/Schema";
-import * as SwarmLimit from "./SwarmLimit.generated.js";
-import * as SwarmResources from "./SwarmResources.generated.js";
+
+import * as SwarmLimit from "./SwarmLimit.generated.ts";
+import * as SwarmResources from "./SwarmResources.generated.ts";
 
 export class SwarmResourceRequirements extends Schema.Class<SwarmResourceRequirements>("SwarmResourceRequirements")(
     {
-        Limits: Schema.optionalWith(SwarmLimit.SwarmLimit, { nullable: true }),
-        Reservations: Schema.optionalWith(SwarmResources.SwarmResources, { nullable: true }),
+        Limits: Schema.optional(Schema.NullOr(SwarmLimit.SwarmLimit)),
+        Reservations: Schema.optional(Schema.NullOr(SwarmResources.SwarmResources)),
     },
     {
         identifier: "SwarmResourceRequirements",

package/src/internal/generated/SwarmResources.generated.ts

@@ -1,14 +1,23 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as SwarmGenericResource from "./SwarmGenericResource.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as SwarmGenericResource from "./SwarmGenericResource.generated.ts";
 
 export class SwarmResources extends Schema.Class<SwarmResources>("SwarmResources")(
     {
-        NanoCPUs: Schema.optional(EffectSchemas.Number.I64),
-        MemoryBytes: Schema.optional(EffectSchemas.Number.I64),
-        GenericResources: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmGenericResource.SwarmGenericResource)), {
-            nullable: true,
-        }),
+        NanoCPUs: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        MemoryBytes: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        GenericResources: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(SwarmGenericResource.SwarmGenericResource)))
+        ),
     },
     {
         identifier: "SwarmResources",

package/src/internal/generated/SwarmRestartPolicy.generated.ts

@@ -1,12 +1,29 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmRestartPolicy extends Schema.Class<SwarmRestartPolicy>("SwarmRestartPolicy")(
     {
-        Condition: Schema.optional(Schema.Literal("none", "on-failure", "any")),
-        Delay: Schema.optionalWith(EffectSchemas.Number.I64, { nullable: true }),
-        MaxAttempts: Schema.optionalWith(EffectSchemas.Number.U64, { nullable: true }),
-        Window: Schema.optionalWith(EffectSchemas.Number.I64, { nullable: true }),
+        Condition: Schema.optional(Schema.Literals(["none", "on-failure", "any"])),
+        Delay: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(
+                    Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+                )
+            )
+        ),
+        MaxAttempts: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+            )
+        ),
+        Window: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(
+                    Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+                )
+            )
+        ),
     },
     {
         identifier: "SwarmRestartPolicy",

package/src/internal/generated/SwarmSeccompOpts.generated.ts

@@ -2,8 +2,8 @@ import * as Schema from "effect/Schema";
 
 export class SwarmSeccompOpts extends Schema.Class<SwarmSeccompOpts>("SwarmSeccompOpts")(
     {
-        Mode: Schema.optional(Schema.Literal("default", "unconfined", "custom")),
-        Profile: Schema.optionalWith(Schema.Uint8Array, { nullable: true }),
+        Mode: Schema.optional(Schema.Literals(["default", "unconfined", "custom"])),
+        Profile: Schema.optional(Schema.NullOr(Schema.Uint8ArrayFromBase64)),
     },
     {
         identifier: "SwarmSeccompOpts",