the-moby-effect 1.51.7 → 1.54.2

package/src/internal/generated/RegistryServiceConfig.generated.ts

@@ -1,20 +1,17 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as RegistryIndexInfo from "./RegistryIndexInfo.generated.js";
+
+import * as EffectSchemas from "effect-schemas";
+
+import * as RegistryIndexInfo from "./RegistryIndexInfo.generated.ts";
 
 export class RegistryServiceConfig extends Schema.Class<RegistryServiceConfig>("RegistryServiceConfig")(
     {
-        AllowNondistributableArtifactsCIDRs: Schema.optionalWith(
-            Schema.Array(Schema.NullOr(EffectSchemas.Internet.CidrBlockFromString)),
-            {
-                nullable: true,
-            }
+        AllowNondistributableArtifactsCIDRs: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(EffectSchemas.Internet.CidrBlockFromString)))
         ),
-        AllowNondistributableArtifactsHostnames: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        AllowNondistributableArtifactsHostnames: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
         InsecureRegistryCIDRs: Schema.NullOr(Schema.Array(Schema.NullOr(EffectSchemas.Internet.CidrBlockFromString))),
-        IndexConfigs: Schema.NullOr(
-            Schema.Record({ key: Schema.String, value: Schema.NullOr(RegistryIndexInfo.RegistryIndexInfo) })
-        ),
+        IndexConfigs: Schema.NullOr(Schema.Record(Schema.String, Schema.NullOr(RegistryIndexInfo.RegistryIndexInfo))),
         Mirrors: Schema.NullOr(Schema.Array(Schema.String)),
     },
     {

package/src/internal/generated/RuntimePluginPrivilege.generated.ts

@@ -4,7 +4,7 @@ export class RuntimePluginPrivilege extends Schema.Class<RuntimePluginPrivilege>
     {
         Name: Schema.optional(Schema.String),
         Description: Schema.optional(Schema.String),
-        Value: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        Value: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
     },
     {
         identifier: "RuntimePluginPrivilege",

package/src/internal/generated/RuntimePluginSpec.generated.ts

@@ -1,15 +1,16 @@
 import * as Schema from "effect/Schema";
-import * as RuntimePluginPrivilege from "./RuntimePluginPrivilege.generated.js";
+
+import * as RuntimePluginPrivilege from "./RuntimePluginPrivilege.generated.ts";
 
 export class RuntimePluginSpec extends Schema.Class<RuntimePluginSpec>("RuntimePluginSpec")(
     {
         name: Schema.optional(Schema.String),
         remote: Schema.optional(Schema.String),
-        privileges: Schema.optionalWith(Schema.Array(Schema.NullOr(RuntimePluginPrivilege.RuntimePluginPrivilege)), {
-            nullable: true,
-        }),
+        privileges: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(RuntimePluginPrivilege.RuntimePluginPrivilege)))
+        ),
         disabled: Schema.optional(Schema.Boolean),
-        env: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        env: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
     },
     {
         identifier: "RuntimePluginSpec",

package/src/internal/generated/StorageDriverData.generated.ts

@@ -2,7 +2,7 @@ import * as Schema from "effect/Schema";
 
 export class StorageDriverData extends Schema.Class<StorageDriverData>("StorageDriverData")(
     {
-        Data: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
+        Data: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
         Name: Schema.String,
     },
     {

package/src/internal/generated/SwarmAnnotations.generated.ts

@@ -3,7 +3,7 @@ import * as Schema from "effect/Schema";
 export class SwarmAnnotations extends Schema.Class<SwarmAnnotations>("SwarmAnnotations")(
     {
         Name: Schema.optional(Schema.String),
-        Labels: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
+        Labels: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
     },
     {
         identifier: "SwarmAnnotations",

package/src/internal/generated/SwarmAppArmorOpts.generated.ts

@@ -2,7 +2,7 @@ import * as Schema from "effect/Schema";
 
 export class SwarmAppArmorOpts extends Schema.Class<SwarmAppArmorOpts>("SwarmAppArmorOpts")(
     {
-        Mode: Schema.optional(Schema.Literal("default", "disabled")),
+        Mode: Schema.optional(Schema.Literals(["default", "disabled"])),
     },
     {
         identifier: "SwarmAppArmorOpts",

package/src/internal/generated/SwarmCAConfig.generated.ts

@@ -1,16 +1,21 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as SwarmExternalCA from "./SwarmExternalCA.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as SwarmExternalCA from "./SwarmExternalCA.generated.ts";
 
 export class SwarmCAConfig extends Schema.Class<SwarmCAConfig>("SwarmCAConfig")(
     {
-        NodeCertExpiry: Schema.optional(EffectSchemas.Number.I64),
-        ExternalCAs: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmExternalCA.SwarmExternalCA)), {
-            nullable: true,
-        }),
+        NodeCertExpiry: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        ExternalCAs: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(SwarmExternalCA.SwarmExternalCA)))),
         SigningCACert: Schema.optional(Schema.String),
         SigningCAKey: Schema.optional(Schema.String),
-        ForceRotate: Schema.optional(EffectSchemas.Number.U64),
+        ForceRotate: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
     },
     {
         identifier: "SwarmCAConfig",

package/src/internal/generated/SwarmClusterInfo.generated.ts

@@ -1,8 +1,9 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as SwarmMeta from "./SwarmMeta.generated.js";
-import * as SwarmSpec from "./SwarmSpec.generated.js";
-import * as SwarmTLSInfo from "./SwarmTLSInfo.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as SwarmMeta from "./SwarmMeta.generated.ts";
+import * as SwarmSpec from "./SwarmSpec.generated.ts";
+import * as SwarmTLSInfo from "./SwarmTLSInfo.generated.ts";
 
 export class SwarmClusterInfo extends Schema.Class<SwarmClusterInfo>("SwarmClusterInfo")(
     {
@@ -12,8 +13,14 @@ export class SwarmClusterInfo extends Schema.Class<SwarmClusterInfo>("SwarmClust
         TLSInfo: Schema.NullOr(SwarmTLSInfo.SwarmTLSInfo),
         RootRotationInProgress: Schema.Boolean,
         DefaultAddrPool: Schema.NullOr(Schema.Array(Schema.String)),
-        SubnetSize: EffectSchemas.Number.U32,
-        DataPathPort: EffectSchemas.Number.U32,
+        SubnetSize: MobyNumber.NumberFromWireString.check(
+            Schema.isInt(),
+            Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+        ),
+        DataPathPort: MobyNumber.NumberFromWireString.check(
+            Schema.isInt(),
+            Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+        ),
     },
     {
         identifier: "SwarmClusterInfo",

package/src/internal/generated/SwarmConfig.generated.ts

@@ -1,7 +1,8 @@
 import * as Schema from "effect/Schema";
+
 import * as MobyIdentifiers from "../schemas/id.ts";
-import * as SwarmConfigSpec from "./SwarmConfigSpec.generated.js";
-import * as SwarmMeta from "./SwarmMeta.generated.js";
+import * as SwarmConfigSpec from "./SwarmConfigSpec.generated.ts";
+import * as SwarmMeta from "./SwarmMeta.generated.ts";
 
 export class SwarmConfig extends Schema.Class<SwarmConfig>("SwarmConfig")(
     {

package/src/internal/generated/SwarmConfigReference.generated.ts

@@ -1,13 +1,12 @@
 import * as Schema from "effect/Schema";
-import * as SwarmConfigReferenceFileTarget from "./SwarmConfigReferenceFileTarget.generated.js";
-import * as SwarmConfigReferenceRuntimeTarget from "./SwarmConfigReferenceRuntimeTarget.generated.js";
+
+import * as SwarmConfigReferenceFileTarget from "./SwarmConfigReferenceFileTarget.generated.ts";
+import * as SwarmConfigReferenceRuntimeTarget from "./SwarmConfigReferenceRuntimeTarget.generated.ts";
 
 export class SwarmConfigReference extends Schema.Class<SwarmConfigReference>("SwarmConfigReference")(
     {
-        File: Schema.optionalWith(SwarmConfigReferenceFileTarget.SwarmConfigReferenceFileTarget, { nullable: true }),
-        Runtime: Schema.optionalWith(SwarmConfigReferenceRuntimeTarget.SwarmConfigReferenceRuntimeTarget, {
-            nullable: true,
-        }),
+        File: Schema.optional(Schema.NullOr(SwarmConfigReferenceFileTarget.SwarmConfigReferenceFileTarget)),
+        Runtime: Schema.optional(Schema.NullOr(SwarmConfigReferenceRuntimeTarget.SwarmConfigReferenceRuntimeTarget)),
         ConfigID: Schema.String,
         ConfigName: Schema.String,
     },

package/src/internal/generated/SwarmConfigReferenceFileTarget.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 SwarmConfigReferenceFileTarget extends Schema.Class<SwarmConfigReferenceFileTarget>(
     "SwarmConfigReferenceFileTarget"
 )(
@@ -8,7 +9,10 @@ export class SwarmConfigReferenceFileTarget extends Schema.Class<SwarmConfigRefe
         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: "SwarmConfigReferenceFileTarget",

package/src/internal/generated/SwarmConfigSpec.generated.ts

@@ -1,12 +1,13 @@
 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 SwarmConfigSpec extends Schema.Class<SwarmConfigSpec>("SwarmConfigSpec")(
     {
         ...SwarmAnnotations.SwarmAnnotations.fields,
-        Data: Schema.optionalWith(Schema.Uint8ArrayFromBase64, { nullable: true }),
-        Templating: Schema.optionalWith(SwarmDriver.SwarmDriver, { nullable: true }),
+        Data: Schema.optional(Schema.NullOr(Schema.Uint8ArrayFromBase64)),
+        Templating: Schema.optional(Schema.NullOr(SwarmDriver.SwarmDriver)),
     },
     {
         identifier: "SwarmConfigSpec",

package/src/internal/generated/SwarmContainerSpec.generated.ts

@@ -1,47 +1,54 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as MountMount from "./MountMount.generated.js";
-import * as SwarmConfigReference from "./SwarmConfigReference.generated.js";
-import * as SwarmDNSConfig from "./SwarmDNSConfig.generated.js";
-import * as SwarmPrivileges from "./SwarmPrivileges.generated.js";
-import * as SwarmSecretReference from "./SwarmSecretReference.generated.js";
-import * as UnitsUlimit from "./UnitsUlimit.generated.js";
-import * as V1HealthcheckConfig from "./V1HealthcheckConfig.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as MountMount from "./MountMount.generated.ts";
+import * as SwarmConfigReference from "./SwarmConfigReference.generated.ts";
+import * as SwarmDNSConfig from "./SwarmDNSConfig.generated.ts";
+import * as SwarmPrivileges from "./SwarmPrivileges.generated.ts";
+import * as SwarmSecretReference from "./SwarmSecretReference.generated.ts";
+import * as UnitsUlimit from "./UnitsUlimit.generated.ts";
+import * as V1HealthcheckConfig from "./V1HealthcheckConfig.generated.ts";
 
 export class SwarmContainerSpec extends Schema.Class<SwarmContainerSpec>("SwarmContainerSpec")(
     {
         Image: Schema.optional(Schema.String),
-        Labels: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
-        Command: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Args: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        Labels: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
+        Command: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Args: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
         Hostname: Schema.optional(Schema.String),
-        Env: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        Env: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
         Dir: Schema.optional(Schema.String),
         User: Schema.optional(Schema.String),
-        Groups: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Privileges: Schema.optionalWith(SwarmPrivileges.SwarmPrivileges, { nullable: true }),
-        Init: Schema.optionalWith(Schema.Boolean, { nullable: true }),
+        Groups: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Privileges: Schema.optional(Schema.NullOr(SwarmPrivileges.SwarmPrivileges)),
+        Init: Schema.optional(Schema.NullOr(Schema.Boolean)),
         StopSignal: Schema.optional(Schema.String),
         TTY: Schema.optional(Schema.Boolean),
         OpenStdin: Schema.optional(Schema.Boolean),
         ReadOnly: Schema.optional(Schema.Boolean),
-        Mounts: Schema.optionalWith(Schema.Array(Schema.NullOr(MountMount.MountMount)), { nullable: true }),
-        StopGracePeriod: Schema.optionalWith(EffectSchemas.Number.I64, { nullable: true }),
-        Healthcheck: Schema.optionalWith(V1HealthcheckConfig.V1HealthcheckConfig, { nullable: true }),
-        Hosts: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        DNSConfig: Schema.optionalWith(SwarmDNSConfig.SwarmDNSConfig, { nullable: true }),
-        Secrets: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmSecretReference.SwarmSecretReference)), {
-            nullable: true,
-        }),
-        Configs: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmConfigReference.SwarmConfigReference)), {
-            nullable: true,
-        }),
-        Isolation: Schema.optional(Schema.Literal("", "default", "process", "hyperv")),
-        Sysctls: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
-        CapabilityAdd: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        CapabilityDrop: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Ulimits: Schema.optionalWith(Schema.Array(Schema.NullOr(UnitsUlimit.UnitsUlimit)), { nullable: true }),
-        OomScoreAdj: Schema.optional(EffectSchemas.Number.I64),
+        Mounts: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(MountMount.MountMount)))),
+        StopGracePeriod: Schema.optional(
+            Schema.NullOr(
+                MobyNumber.BigIntFromWireString.check(
+                    Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+                )
+            )
+        ),
+        Healthcheck: Schema.optional(Schema.NullOr(V1HealthcheckConfig.V1HealthcheckConfig)),
+        Hosts: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        DNSConfig: Schema.optional(Schema.NullOr(SwarmDNSConfig.SwarmDNSConfig)),
+        Secrets: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(SwarmSecretReference.SwarmSecretReference)))),
+        Configs: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(SwarmConfigReference.SwarmConfigReference)))),
+        Isolation: Schema.optional(Schema.Literals(["", "default", "process", "hyperv"])),
+        Sysctls: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
+        CapabilityAdd: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        CapabilityDrop: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Ulimits: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(UnitsUlimit.UnitsUlimit)))),
+        OomScoreAdj: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
     },
     {
         identifier: "SwarmContainerSpec",

package/src/internal/generated/SwarmContainerStatus.generated.ts

@@ -1,11 +1,17 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmContainerStatus extends Schema.Class<SwarmContainerStatus>("SwarmContainerStatus")(
     {
-        ContainerID: Schema.String,
-        PID: EffectSchemas.Number.I64,
-        ExitCode: EffectSchemas.Number.I64,
+        ContainerID: MobyIdentifiers.ContainerIdentifier,
+        PID: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        ExitCode: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
     },
     {
         identifier: "SwarmContainerStatus",

package/src/internal/generated/SwarmDNSConfig.generated.ts

@@ -2,9 +2,9 @@ import * as Schema from "effect/Schema";
 
 export class SwarmDNSConfig extends Schema.Class<SwarmDNSConfig>("SwarmDNSConfig")(
     {
-        Nameservers: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Search: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Options: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        Nameservers: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Search: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Options: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
     },
     {
         identifier: "SwarmDNSConfig",

package/src/internal/generated/SwarmDiscreteGenericResource.generated.ts

@@ -1,12 +1,17 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SwarmDiscreteGenericResource extends Schema.Class<SwarmDiscreteGenericResource>(
     "SwarmDiscreteGenericResource"
 )(
     {
         Kind: Schema.optional(Schema.String),
-        Value: Schema.optional(EffectSchemas.Number.I64),
+        Value: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
     },
     {
         identifier: "SwarmDiscreteGenericResource",

package/src/internal/generated/SwarmDispatcherConfig.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 SwarmDispatcherConfig extends Schema.Class<SwarmDispatcherConfig>("SwarmDispatcherConfig")(
     {
-        HeartbeatPeriod: Schema.optional(EffectSchemas.Number.I64),
+        HeartbeatPeriod: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
     },
     {
         identifier: "SwarmDispatcherConfig",

package/src/internal/generated/SwarmDriver.generated.ts

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

package/src/internal/generated/SwarmEndpoint.generated.ts

@@ -1,15 +1,16 @@
 import * as Schema from "effect/Schema";
-import * as SwarmEndpointSpec from "./SwarmEndpointSpec.generated.js";
-import * as SwarmEndpointVirtualIP from "./SwarmEndpointVirtualIP.generated.js";
-import * as SwarmPortConfig from "./SwarmPortConfig.generated.js";
+
+import * as SwarmEndpointSpec from "./SwarmEndpointSpec.generated.ts";
+import * as SwarmEndpointVirtualIP from "./SwarmEndpointVirtualIP.generated.ts";
+import * as SwarmPortConfig from "./SwarmPortConfig.generated.ts";
 
 export class SwarmEndpoint extends Schema.Class<SwarmEndpoint>("SwarmEndpoint")(
     {
-        Spec: Schema.optionalWith(SwarmEndpointSpec.SwarmEndpointSpec, { nullable: true }),
-        Ports: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmPortConfig.SwarmPortConfig)), { nullable: true }),
-        VirtualIPs: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmEndpointVirtualIP.SwarmEndpointVirtualIP)), {
-            nullable: true,
-        }),
+        Spec: Schema.optional(Schema.NullOr(SwarmEndpointSpec.SwarmEndpointSpec)),
+        Ports: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(SwarmPortConfig.SwarmPortConfig)))),
+        VirtualIPs: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(SwarmEndpointVirtualIP.SwarmEndpointVirtualIP)))
+        ),
     },
     {
         identifier: "SwarmEndpoint",

package/src/internal/generated/SwarmEndpointSpec.generated.ts

@@ -1,10 +1,11 @@
 import * as Schema from "effect/Schema";
-import * as SwarmPortConfig from "./SwarmPortConfig.generated.js";
+
+import * as SwarmPortConfig from "./SwarmPortConfig.generated.ts";
 
 export class SwarmEndpointSpec extends Schema.Class<SwarmEndpointSpec>("SwarmEndpointSpec")(
     {
-        Mode: Schema.optional(Schema.Literal("vip", "dnsrr")),
-        Ports: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmPortConfig.SwarmPortConfig)), { nullable: true }),
+        Mode: Schema.optional(Schema.Literals(["vip", "dnsrr"])),
+        Ports: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(SwarmPortConfig.SwarmPortConfig)))),
     },
     {
         identifier: "SwarmEndpointSpec",

package/src/internal/generated/SwarmEngineDescription.generated.ts

@@ -1,13 +1,14 @@
 import * as Schema from "effect/Schema";
-import * as SwarmPluginDescription from "./SwarmPluginDescription.generated.js";
+
+import * as SwarmPluginDescription from "./SwarmPluginDescription.generated.ts";
 
 export class SwarmEngineDescription extends Schema.Class<SwarmEngineDescription>("SwarmEngineDescription")(
     {
         EngineVersion: Schema.optional(Schema.String),
-        Labels: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
-        Plugins: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmPluginDescription.SwarmPluginDescription)), {
-            nullable: true,
-        }),
+        Labels: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
+        Plugins: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(SwarmPluginDescription.SwarmPluginDescription)))
+        ),
     },
     {
         identifier: "SwarmEngineDescription",

package/src/internal/generated/SwarmExternalCA.generated.ts

@@ -4,7 +4,7 @@ export class SwarmExternalCA extends Schema.Class<SwarmExternalCA>("SwarmExterna
     {
         Protocol: Schema.Literal("cfssl"),
         URL: Schema.String,
-        Options: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
+        Options: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
         CACert: Schema.String,
     },
     {

package/src/internal/generated/SwarmGenericResource.generated.ts

@@ -1,13 +1,12 @@
 import * as Schema from "effect/Schema";
-import * as SwarmDiscreteGenericResource from "./SwarmDiscreteGenericResource.generated.js";
-import * as SwarmNamedGenericResource from "./SwarmNamedGenericResource.generated.js";
+
+import * as SwarmDiscreteGenericResource from "./SwarmDiscreteGenericResource.generated.ts";
+import * as SwarmNamedGenericResource from "./SwarmNamedGenericResource.generated.ts";
 
 export class SwarmGenericResource extends Schema.Class<SwarmGenericResource>("SwarmGenericResource")(
     {
-        NamedResourceSpec: Schema.optionalWith(SwarmNamedGenericResource.SwarmNamedGenericResource, { nullable: true }),
-        DiscreteResourceSpec: Schema.optionalWith(SwarmDiscreteGenericResource.SwarmDiscreteGenericResource, {
-            nullable: true,
-        }),
+        NamedResourceSpec: Schema.optional(Schema.NullOr(SwarmNamedGenericResource.SwarmNamedGenericResource)),
+        DiscreteResourceSpec: Schema.optional(Schema.NullOr(SwarmDiscreteGenericResource.SwarmDiscreteGenericResource)),
     },
     {
         identifier: "SwarmGenericResource",

package/src/internal/generated/SwarmIPAMOptions.generated.ts

@@ -1,11 +1,12 @@
 import * as Schema from "effect/Schema";
-import * as SwarmDriver from "./SwarmDriver.generated.js";
-import * as SwarmIPAMConfig from "./SwarmIPAMConfig.generated.js";
+
+import * as SwarmDriver from "./SwarmDriver.generated.ts";
+import * as SwarmIPAMConfig from "./SwarmIPAMConfig.generated.ts";
 
 export class SwarmIPAMOptions extends Schema.Class<SwarmIPAMOptions>("SwarmIPAMOptions")(
     {
-        Driver: Schema.optionalWith(SwarmDriver.SwarmDriver, { nullable: true }),
-        Configs: Schema.optionalWith(Schema.Array(Schema.NullOr(SwarmIPAMConfig.SwarmIPAMConfig)), { nullable: true }),
+        Driver: Schema.optional(Schema.NullOr(SwarmDriver.SwarmDriver)),
+        Configs: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(SwarmIPAMConfig.SwarmIPAMConfig)))),
     },
     {
         identifier: "SwarmIPAMOptions",

package/src/internal/generated/SwarmInfo.generated.ts

@@ -1,20 +1,30 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as SwarmClusterInfo from "./SwarmClusterInfo.generated.js";
-import * as SwarmPeer from "./SwarmPeer.generated.js";
+
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as MobyNumber from "../schemas/number.ts";
+import * as SwarmClusterInfo from "./SwarmClusterInfo.generated.ts";
+import * as SwarmPeer from "./SwarmPeer.generated.ts";
 
 export class SwarmInfo extends Schema.Class<SwarmInfo>("SwarmInfo")(
     {
-        NodeID: Schema.String,
+        NodeID: MobyIdentifiers.NodeIdentifier,
         NodeAddr: Schema.String,
-        LocalNodeState: Schema.Literal("inactive", "pending", "active", "error", "locked"),
+        LocalNodeState: Schema.Literals(["inactive", "pending", "active", "error", "locked"]),
         ControlAvailable: Schema.Boolean,
         Error: Schema.String,
         RemoteManagers: Schema.NullOr(Schema.Array(Schema.NullOr(SwarmPeer.SwarmPeer))),
-        Nodes: Schema.optional(EffectSchemas.Number.I64),
-        Managers: Schema.optional(EffectSchemas.Number.I64),
-        Cluster: Schema.optionalWith(SwarmClusterInfo.SwarmClusterInfo, { nullable: true }),
-        Warnings: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        Nodes: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        Managers: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        Cluster: Schema.optional(Schema.NullOr(SwarmClusterInfo.SwarmClusterInfo)),
+        Warnings: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
     },
     {
         identifier: "SwarmInfo",

package/src/internal/generated/SwarmInitRequest.generated.ts

@@ -1,33 +1,31 @@
-import * as EffectSchemas from "effect-schemas";
+import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import * as SwarmSpec from "./SwarmSpec.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as SwarmSpec from "./SwarmSpec.generated.ts";
 
 export class SwarmInitRequest extends Schema.Class<SwarmInitRequest>("SwarmInitRequest")(
     {
-        ListenAddr: Schema.String.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => "0.0.0.0:2377")
-        ),
-        AdvertiseAddr: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        DataPathAddr: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        DataPathPort: EffectSchemas.Number.U32.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.U32.make(0))
-        ),
-        ForceNewCluster: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        Spec: Schema.NullOr(SwarmSpec.SwarmSpec)
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        AutoLockManagers: Schema.Boolean.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => false)
+        ListenAddr: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed("0.0.0.0:2377"))),
+        AdvertiseAddr: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        DataPathAddr: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        DataPathPort: MobyNumber.NumberFromWireString.check(
+            Schema.isInt(),
+            Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0))),
+        ForceNewCluster: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        Spec: Schema.NullOr(SwarmSpec.SwarmSpec).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+        AutoLockManagers: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        Availability: Schema.Literals(["active", "pause", "drain"]).pipe(
+            Schema.withConstructorDefault(Effect.succeed("active"))
         ),
-        Availability: Schema.Literal("active", "pause", "drain")
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => "active")),
-        DefaultAddrPool: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        SubnetSize: EffectSchemas.Number.U32.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.U32.make(24))
+        DefaultAddrPool: Schema.NullOr(Schema.Array(Schema.String)).pipe(
+            Schema.withConstructorDefault(Effect.succeed([]))
         ),
+        SubnetSize: MobyNumber.NumberFromWireString.check(
+            Schema.isInt(),
+            Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(24))),
     },
     {
         identifier: "SwarmInitRequest",