the-moby-effect 1.51.6 → 1.54.1

package/src/internal/generated/SystemInfo.generated.ts

@@ -1,29 +1,40 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as RegistryServiceConfig from "./RegistryServiceConfig.generated.js";
-import * as SwarmGenericResource from "./SwarmGenericResource.generated.js";
-import * as SwarmInfo from "./SwarmInfo.generated.js";
-import * as SystemCommit from "./SystemCommit.generated.js";
-import * as SystemContainerdInfo from "./SystemContainerdInfo.generated.js";
-import * as SystemDeviceInfo from "./SystemDeviceInfo.generated.js";
-import * as SystemFirewallInfo from "./SystemFirewallInfo.generated.js";
-import * as SystemNetworkAddressPool from "./SystemNetworkAddressPool.generated.js";
-import * as SystemPluginsInfo from "./SystemPluginsInfo.generated.js";
-import * as SystemRuntimeWithStatus from "./SystemRuntimeWithStatus.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as RegistryServiceConfig from "./RegistryServiceConfig.generated.ts";
+import * as SwarmGenericResource from "./SwarmGenericResource.generated.ts";
+import * as SwarmInfo from "./SwarmInfo.generated.ts";
+import * as SystemCommit from "./SystemCommit.generated.ts";
+import * as SystemContainerdInfo from "./SystemContainerdInfo.generated.ts";
+import * as SystemDeviceInfo from "./SystemDeviceInfo.generated.ts";
+import * as SystemFirewallInfo from "./SystemFirewallInfo.generated.ts";
+import * as SystemNetworkAddressPool from "./SystemNetworkAddressPool.generated.ts";
+import * as SystemPluginsInfo from "./SystemPluginsInfo.generated.ts";
+import * as SystemRuntimeWithStatus from "./SystemRuntimeWithStatus.generated.ts";
 
 export class SystemInfo extends Schema.Class<SystemInfo>("SystemInfo")(
     {
         ID: Schema.String,
-        Containers: EffectSchemas.Number.I64,
-        ContainersRunning: EffectSchemas.Number.I64,
-        ContainersPaused: EffectSchemas.Number.I64,
-        ContainersStopped: EffectSchemas.Number.I64,
-        Images: EffectSchemas.Number.I64,
+        Containers: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        ContainersRunning: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        ContainersPaused: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        ContainersStopped: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        Images: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         Driver: Schema.String,
-        DriverStatus: Schema.NullOr(Schema.Array(Schema.Array(Schema.String).pipe(Schema.itemsCount(2)))),
-        SystemStatus: Schema.optionalWith(Schema.Array(Schema.Array(Schema.String).pipe(Schema.itemsCount(2))), {
-            nullable: true,
-        }),
+        DriverStatus: Schema.NullOr(Schema.Array(Schema.Array(Schema.String).check(Schema.isLengthBetween(2, 2)))),
+        SystemStatus: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.Array(Schema.String).check(Schema.isLengthBetween(2, 2))))
+        ),
         Plugins: Schema.NullOr(SystemPluginsInfo.SystemPluginsInfo),
         MemoryLimit: Schema.Boolean,
         SwapLimit: Schema.Boolean,
@@ -36,14 +47,20 @@ export class SystemInfo extends Schema.Class<SystemInfo>("SystemInfo")(
         PidsLimit: Schema.Boolean,
         IPv4Forwarding: Schema.Boolean,
         Debug: Schema.Boolean,
-        NFd: EffectSchemas.Number.I64,
+        NFd: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         OomKillDisable: Schema.Boolean,
-        NGoroutines: EffectSchemas.Number.I64,
+        NGoroutines: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         SystemTime: Schema.String,
         LoggingDriver: Schema.String,
         CgroupDriver: Schema.String,
         CgroupVersion: Schema.optional(Schema.String),
-        NEventsListener: EffectSchemas.Number.I64,
+        NEventsListener: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         KernelVersion: Schema.String,
         OperatingSystem: Schema.String,
         OSVersion: Schema.String,
@@ -51,8 +68,12 @@ export class SystemInfo extends Schema.Class<SystemInfo>("SystemInfo")(
         Architecture: Schema.String,
         IndexServerAddress: Schema.String,
         RegistryConfig: Schema.NullOr(RegistryServiceConfig.RegistryServiceConfig),
-        NCPU: EffectSchemas.Number.I64,
-        MemTotal: EffectSchemas.Number.I64,
+        NCPU: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        MemTotal: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         GenericResources: Schema.NullOr(Schema.Array(Schema.NullOr(SwarmGenericResource.SwarmGenericResource))),
         DockerRootDir: Schema.String,
         HttpProxy: Schema.String,
@@ -63,28 +84,27 @@ export class SystemInfo extends Schema.Class<SystemInfo>("SystemInfo")(
         ExperimentalBuild: Schema.Boolean,
         ServerVersion: Schema.String,
         Runtimes: Schema.NullOr(
-            Schema.Record({ key: Schema.String, value: Schema.NullOr(SystemRuntimeWithStatus.SystemRuntimeWithStatus) })
+            Schema.Record(Schema.String, Schema.NullOr(SystemRuntimeWithStatus.SystemRuntimeWithStatus))
         ),
         DefaultRuntime: Schema.String,
         Swarm: Schema.NullOr(SwarmInfo.SwarmInfo),
         LiveRestoreEnabled: Schema.Boolean,
-        Isolation: Schema.Literal("", "default", "process", "hyperv"),
+        Isolation: Schema.Literals(["", "default", "process", "hyperv"]),
         InitBinary: Schema.String,
         ContainerdCommit: Schema.NullOr(SystemCommit.SystemCommit),
         RuncCommit: Schema.NullOr(SystemCommit.SystemCommit),
         InitCommit: Schema.NullOr(SystemCommit.SystemCommit),
         SecurityOptions: Schema.NullOr(Schema.Array(Schema.String)),
         ProductLicense: Schema.optional(Schema.String),
-        DefaultAddressPools: Schema.optionalWith(
-            Schema.Array(Schema.NullOr(SystemNetworkAddressPool.SystemNetworkAddressPool)),
-            { nullable: true }
+        DefaultAddressPools: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(SystemNetworkAddressPool.SystemNetworkAddressPool)))
         ),
-        FirewallBackend: Schema.optionalWith(SystemFirewallInfo.SystemFirewallInfo, { nullable: true }),
+        FirewallBackend: Schema.optional(Schema.NullOr(SystemFirewallInfo.SystemFirewallInfo)),
         CDISpecDirs: Schema.NullOr(Schema.Array(Schema.String)),
-        DiscoveredDevices: Schema.optionalWith(Schema.Array(Schema.NullOr(SystemDeviceInfo.SystemDeviceInfo)), {
-            nullable: true,
-        }),
-        Containerd: Schema.optionalWith(SystemContainerdInfo.SystemContainerdInfo, { nullable: true }),
+        DiscoveredDevices: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(SystemDeviceInfo.SystemDeviceInfo)))
+        ),
+        Containerd: Schema.optional(Schema.NullOr(SystemContainerdInfo.SystemContainerdInfo)),
         Warnings: Schema.NullOr(Schema.Array(Schema.String)),
     },
     {

package/src/internal/generated/SystemNetworkAddressPool.generated.ts

@@ -1,10 +1,13 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class SystemNetworkAddressPool extends Schema.Class<SystemNetworkAddressPool>("SystemNetworkAddressPool")(
     {
         Base: Schema.String,
-        Size: EffectSchemas.Number.I64,
+        Size: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
     },
     {
         identifier: "SystemNetworkAddressPool",

package/src/internal/generated/SystemRuntime.generated.ts

@@ -3,9 +3,9 @@ import * as Schema from "effect/Schema";
 export class SystemRuntime extends Schema.Class<SystemRuntime>("SystemRuntime")(
     {
         path: Schema.optional(Schema.String),
-        runtimeArgs: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        runtimeArgs: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
         runtimeType: Schema.optional(Schema.String),
-        options: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.Object }), { nullable: true }),
+        options: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.ObjectKeyword))),
     },
     {
         identifier: "SystemRuntime",

package/src/internal/generated/SystemRuntimeWithStatus.generated.ts

@@ -1,10 +1,11 @@
 import * as Schema from "effect/Schema";
-import * as SystemRuntime from "./SystemRuntime.generated.js";
+
+import * as SystemRuntime from "./SystemRuntime.generated.ts";
 
 export class SystemRuntimeWithStatus extends Schema.Class<SystemRuntimeWithStatus>("SystemRuntimeWithStatus")(
     {
         ...SystemRuntime.SystemRuntime.fields,
-        status: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
+        status: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
     },
     {
         identifier: "SystemRuntimeWithStatus",

package/src/internal/generated/TypesComponentVersion.generated.ts

@@ -4,7 +4,7 @@ export class TypesComponentVersion extends Schema.Class<TypesComponentVersion>("
     {
         Name: Schema.String,
         Version: Schema.String,
-        Details: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
+        Details: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
     },
     {
         identifier: "TypesComponentVersion",

package/src/internal/generated/TypesDiskUsage.generated.ts

@@ -1,18 +1,28 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as BuildCacheRecord from "./BuildCacheRecord.generated.js";
-import * as ContainerSummary from "./ContainerSummary.generated.js";
-import * as ImageSummary from "./ImageSummary.generated.js";
-import * as VolumeVolume from "./VolumeVolume.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as BuildCacheRecord from "./BuildCacheRecord.generated.ts";
+import * as ContainerSummary from "./ContainerSummary.generated.ts";
+import * as ImageSummary from "./ImageSummary.generated.ts";
+import * as VolumeVolume from "./VolumeVolume.generated.ts";
 
 export class TypesDiskUsage extends Schema.Class<TypesDiskUsage>("TypesDiskUsage")(
     {
-        LayersSize: Schema.optional(EffectSchemas.Number.I64), // optional for docker.io/library/docker:26-dind-rootless
+        // optional for docker.io/library/docker:dind-rootless (deprecated, omitted since docker v29)
+        LayersSize: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
         Images: Schema.NullOr(Schema.Array(Schema.NullOr(ImageSummary.ImageSummary))),
         Containers: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerSummary.ContainerSummary))),
         Volumes: Schema.NullOr(Schema.Array(Schema.NullOr(VolumeVolume.VolumeVolume))),
         BuildCache: Schema.NullOr(Schema.Array(Schema.NullOr(BuildCacheRecord.BuildCacheRecord))),
-        BuilderSize: Schema.optional(EffectSchemas.Number.I64),
+        BuilderSize: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
     },
     {
         identifier: "TypesDiskUsage",

package/src/internal/generated/TypesPlugin.generated.ts

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

package/src/internal/generated/TypesPluginConfig.generated.ts

@@ -1,12 +1,13 @@
 import * as Schema from "effect/Schema";
-import * as TypesPluginConfigArgs from "./TypesPluginConfigArgs.generated.js";
-import * as TypesPluginConfigInterface from "./TypesPluginConfigInterface.generated.js";
-import * as TypesPluginConfigLinux from "./TypesPluginConfigLinux.generated.js";
-import * as TypesPluginConfigNetwork from "./TypesPluginConfigNetwork.generated.js";
-import * as TypesPluginConfigRootfs from "./TypesPluginConfigRootfs.generated.js";
-import * as TypesPluginConfigUser from "./TypesPluginConfigUser.generated.js";
-import * as TypesPluginEnv from "./TypesPluginEnv.generated.js";
-import * as TypesPluginMount from "./TypesPluginMount.generated.js";
+
+import * as TypesPluginConfigArgs from "./TypesPluginConfigArgs.generated.ts";
+import * as TypesPluginConfigInterface from "./TypesPluginConfigInterface.generated.ts";
+import * as TypesPluginConfigLinux from "./TypesPluginConfigLinux.generated.ts";
+import * as TypesPluginConfigNetwork from "./TypesPluginConfigNetwork.generated.ts";
+import * as TypesPluginConfigRootfs from "./TypesPluginConfigRootfs.generated.ts";
+import * as TypesPluginConfigUser from "./TypesPluginConfigUser.generated.ts";
+import * as TypesPluginEnv from "./TypesPluginEnv.generated.ts";
+import * as TypesPluginMount from "./TypesPluginMount.generated.ts";
 
 export class TypesPluginConfig extends Schema.Class<TypesPluginConfig>("TypesPluginConfig")(
     {
@@ -23,9 +24,9 @@ export class TypesPluginConfig extends Schema.Class<TypesPluginConfig>("TypesPlu
         Network: Schema.NullOr(TypesPluginConfigNetwork.TypesPluginConfigNetwork),
         PidHost: Schema.Boolean,
         PropagatedMount: Schema.String,
-        User: Schema.optionalWith(TypesPluginConfigUser.TypesPluginConfigUser, { nullable: true }),
+        User: Schema.optional(Schema.NullOr(TypesPluginConfigUser.TypesPluginConfigUser)),
         WorkDir: Schema.String,
-        rootfs: Schema.optionalWith(TypesPluginConfigRootfs.TypesPluginConfigRootfs, { nullable: true }),
+        rootfs: Schema.optional(Schema.NullOr(TypesPluginConfigRootfs.TypesPluginConfigRootfs)),
     },
     {
         identifier: "TypesPluginConfig",

package/src/internal/generated/TypesPluginConfigInterface.generated.ts

@@ -1,41 +1,11 @@
-import * as Option from "effect/Option";
-import * as ParseResult from "effect/ParseResult";
 import * as Schema from "effect/Schema";
-import * as String from "effect/String";
-import * as TypesPluginInterfaceType from "./TypesPluginInterfaceType.generated.js";
 
 export class TypesPluginConfigInterface extends Schema.Class<TypesPluginConfigInterface>("TypesPluginConfigInterface")(
     {
         ProtocolScheme: Schema.optional(Schema.String),
         Socket: Schema.String,
         Types: Schema.NullOr(
-            Schema.Array(
-                Schema.transformOrFail(
-                    Schema.TemplateLiteral(Schema.String, ".", Schema.String, "/", Schema.String),
-                    TypesPluginInterfaceType.TypesPluginInterfaceType,
-                    {
-                        encode: ({ Capability, Prefix, Version }) =>
-                            ParseResult.succeed(`${Prefix}.${Capability}/${Version}` as const),
-                        decode: (asString, _options, ast) => {
-                            const PrefixCapabilitySplit = String.indexOf(".")(asString);
-                            const CapabilityVersionSplit = String.lastIndexOf("/")(asString);
-
-                            if (Option.isNone(PrefixCapabilitySplit) || Option.isNone(CapabilityVersionSplit)) {
-                                return ParseResult.fail(new ParseResult.Type(ast, asString, "Invalid format"));
-                            }
-
-                            return ParseResult.succeed({
-                                Prefix: String.substring(0, PrefixCapabilitySplit.value)(asString),
-                                Version: String.substring(CapabilityVersionSplit.value + 1)(asString),
-                                Capability: String.substring(
-                                    PrefixCapabilitySplit.value + 1,
-                                    CapabilityVersionSplit.value
-                                )(asString),
-                            });
-                        },
-                    }
-                )
-            )
+            Schema.Array(Schema.NullOr(Schema.TemplateLiteral([Schema.String, ".", Schema.String, "/", Schema.String])))
         ),
     },
     {

package/src/internal/generated/TypesPluginConfigLinux.generated.ts

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

package/src/internal/generated/TypesPluginConfigUser.generated.ts

@@ -1,10 +1,21 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class TypesPluginConfigUser extends Schema.Class<TypesPluginConfigUser>("TypesPluginConfigUser")(
     {
-        GID: Schema.optional(EffectSchemas.Number.U32),
-        UID: Schema.optional(EffectSchemas.Number.U32),
+        GID: Schema.optional(
+            MobyNumber.NumberFromWireString.check(
+                Schema.isInt(),
+                Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+            )
+        ),
+        UID: Schema.optional(
+            MobyNumber.NumberFromWireString.check(
+                Schema.isInt(),
+                Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+            )
+        ),
     },
     {
         identifier: "TypesPluginConfigUser",

package/src/internal/generated/TypesPluginSettings.generated.ts

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

package/src/internal/generated/TypesVersion.generated.ts

@@ -1,5 +1,6 @@
 import * as Schema from "effect/Schema";
-import * as TypesComponentVersion from "./TypesComponentVersion.generated.js";
+
+import * as TypesComponentVersion from "./TypesComponentVersion.generated.ts";
 
 export class TypesVersion extends Schema.Class<TypesVersion>("TypesVersion")(
     {
@@ -8,9 +9,9 @@ export class TypesVersion extends Schema.Class<TypesVersion>("TypesVersion")(
                 Name: Schema.String,
             })
         ),
-        Components: Schema.optionalWith(Schema.Array(Schema.NullOr(TypesComponentVersion.TypesComponentVersion)), {
-            nullable: true,
-        }),
+        Components: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(TypesComponentVersion.TypesComponentVersion)))
+        ),
         Version: Schema.String,
         ApiVersion: Schema.String,
         MinAPIVersion: Schema.optional(Schema.String),

package/src/internal/generated/UnitsUlimit.generated.ts

@@ -1,11 +1,16 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class UnitsUlimit extends Schema.Class<UnitsUlimit>("UnitsUlimit")(
     {
         Name: Schema.String,
-        Hard: EffectSchemas.Number.I64,
-        Soft: EffectSchemas.Number.I64,
+        Hard: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        Soft: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
     },
     {
         identifier: "UnitsUlimit",

package/src/internal/generated/V1Descriptor.generated.ts

@@ -1,19 +1,20 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
+
 import * as MobyIdentifiers from "../schemas/id.ts";
-import * as V1Platform from "./V1Platform.generated.js";
+import * as MobyNumber from "../schemas/number.ts";
+import * as V1Platform from "./V1Platform.generated.ts";
 
 export class V1Descriptor extends Schema.Class<V1Descriptor>("V1Descriptor")(
     {
         mediaType: Schema.String,
         digest: MobyIdentifiers.Digest,
-        size: EffectSchemas.Number.I64,
-        urls: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        annotations: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), {
-            nullable: true,
-        }),
-        data: Schema.optionalWith(Schema.Uint8Array, { nullable: true }),
-        platform: Schema.optionalWith(V1Platform.V1Platform, { nullable: true }),
+        size: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        urls: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        annotations: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
+        data: Schema.optional(Schema.NullOr(Schema.Uint8ArrayFromBase64)),
+        platform: Schema.optional(Schema.NullOr(V1Platform.V1Platform)),
         artifactType: Schema.optional(Schema.String),
     },
     {

package/src/internal/generated/V1DockerOCIImageConfig.generated.ts

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

package/src/internal/generated/V1DockerOCIImageConfigExt.generated.ts

@@ -1,11 +1,12 @@
 import * as Schema from "effect/Schema";
-import * as V1HealthcheckConfig from "./V1HealthcheckConfig.generated.js";
+
+import * as V1HealthcheckConfig from "./V1HealthcheckConfig.generated.ts";
 
 export class V1DockerOCIImageConfigExt extends Schema.Class<V1DockerOCIImageConfigExt>("V1DockerOCIImageConfigExt")(
     {
-        Healthcheck: Schema.optionalWith(V1HealthcheckConfig.V1HealthcheckConfig, { nullable: true }),
-        OnBuild: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Shell: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        Healthcheck: Schema.optional(Schema.NullOr(V1HealthcheckConfig.V1HealthcheckConfig)),
+        OnBuild: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Shell: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
     },
     {
         identifier: "V1DockerOCIImageConfigExt",

package/src/internal/generated/V1HealthcheckConfig.generated.ts

@@ -1,14 +1,35 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class V1HealthcheckConfig extends Schema.Class<V1HealthcheckConfig>("V1HealthcheckConfig")(
     {
-        Test: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Interval: Schema.optional(EffectSchemas.Number.I64),
-        Timeout: Schema.optional(EffectSchemas.Number.I64),
-        StartPeriod: Schema.optional(EffectSchemas.Number.I64),
-        StartInterval: Schema.optional(EffectSchemas.Number.I64),
-        Retries: Schema.optional(EffectSchemas.Number.I64),
+        Test: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Interval: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        Timeout: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        StartPeriod: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        StartInterval: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        Retries: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
     },
     {
         identifier: "V1HealthcheckConfig",

package/src/internal/generated/V1ImageConfig.generated.ts

@@ -3,15 +3,13 @@ import * as Schema from "effect/Schema";
 export class V1ImageConfig extends Schema.Class<V1ImageConfig>("V1ImageConfig")(
     {
         User: Schema.optional(Schema.String),
-        ExposedPorts: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.Object }), {
-            nullable: true,
-        }),
-        Env: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Entrypoint: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Cmd: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
-        Volumes: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.Object }), { nullable: true }),
+        ExposedPorts: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.ObjectKeyword))),
+        Env: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Entrypoint: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Cmd: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+        Volumes: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.ObjectKeyword))),
         WorkingDir: Schema.optional(Schema.String),
-        Labels: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
+        Labels: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
         StopSignal: Schema.optional(Schema.String),
         ArgsEscaped: Schema.optional(Schema.Boolean),
     },

package/src/internal/generated/V1Platform.generated.ts

@@ -5,7 +5,7 @@ export class V1Platform extends Schema.Class<V1Platform>("V1Platform")(
         architecture: Schema.String,
         os: Schema.String,
         "os.version": Schema.optional(Schema.String),
-        "os.features": Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        "os.features": Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
         variant: Schema.optional(Schema.String),
     },
     {

package/src/internal/generated/VolumeAccessMode.generated.ts

@@ -1,13 +1,14 @@
 import * as Schema from "effect/Schema";
-import * as VolumeTypeBlock from "./VolumeTypeBlock.generated.js";
-import * as VolumeTypeMount from "./VolumeTypeMount.generated.js";
+
+import * as VolumeTypeBlock from "./VolumeTypeBlock.generated.ts";
+import * as VolumeTypeMount from "./VolumeTypeMount.generated.ts";
 
 export class VolumeAccessMode extends Schema.Class<VolumeAccessMode>("VolumeAccessMode")(
     {
-        Scope: Schema.optional(Schema.Literal("single", "multi")),
-        Sharing: Schema.optional(Schema.Literal("none", "readonly", "onewriter", "all")),
-        MountVolume: Schema.optionalWith(VolumeTypeMount.VolumeTypeMount, { nullable: true }),
-        BlockVolume: Schema.optionalWith(VolumeTypeBlock.VolumeTypeBlock, { nullable: true }),
+        Scope: Schema.optional(Schema.Literals(["single", "multi"])),
+        Sharing: Schema.optional(Schema.Literals(["none", "readonly", "onewriter", "all"])),
+        MountVolume: Schema.optional(Schema.NullOr(VolumeTypeMount.VolumeTypeMount)),
+        BlockVolume: Schema.optional(Schema.NullOr(VolumeTypeBlock.VolumeTypeBlock)),
     },
     {
         identifier: "VolumeAccessMode",

package/src/internal/generated/VolumeCapacityRange.generated.ts

@@ -1,10 +1,15 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class VolumeCapacityRange extends Schema.Class<VolumeCapacityRange>("VolumeCapacityRange")(
     {
-        RequiredBytes: EffectSchemas.Number.I64,
-        LimitBytes: EffectSchemas.Number.I64,
+        RequiredBytes: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        LimitBytes: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
     },
     {
         identifier: "VolumeCapacityRange",

package/src/internal/generated/VolumeClusterVolume.generated.ts

@@ -1,18 +1,19 @@
 import * as Schema from "effect/Schema";
-import * as SwarmMeta from "./SwarmMeta.generated.js";
-import * as VolumeClusterVolumeSpec from "./VolumeClusterVolumeSpec.generated.js";
-import * as VolumeInfo from "./VolumeInfo.generated.js";
-import * as VolumePublishStatus from "./VolumePublishStatus.generated.js";
+
+import * as SwarmMeta from "./SwarmMeta.generated.ts";
+import * as VolumeClusterVolumeSpec from "./VolumeClusterVolumeSpec.generated.ts";
+import * as VolumeInfo from "./VolumeInfo.generated.ts";
+import * as VolumePublishStatus from "./VolumePublishStatus.generated.ts";
 
 export class VolumeClusterVolume extends Schema.Class<VolumeClusterVolume>("VolumeClusterVolume")(
     {
         ID: Schema.String,
         ...SwarmMeta.SwarmMeta.fields,
         Spec: Schema.NullOr(VolumeClusterVolumeSpec.VolumeClusterVolumeSpec),
-        PublishStatus: Schema.optionalWith(Schema.Array(Schema.NullOr(VolumePublishStatus.VolumePublishStatus)), {
-            nullable: true,
-        }),
-        Info: Schema.optionalWith(VolumeInfo.VolumeInfo, { nullable: true }),
+        PublishStatus: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(VolumePublishStatus.VolumePublishStatus)))
+        ),
+        Info: Schema.optional(Schema.NullOr(VolumeInfo.VolumeInfo)),
     },
     {
         identifier: "VolumeClusterVolume",