the-moby-effect 1.51.6 → 1.54.1

package/src/internal/generated/ContainerResources.generated.ts

@@ -1,96 +1,109 @@
-import * as EffectSchemas from "effect-schemas";
+import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import * as BlkiodevThrottleDevice from "./BlkiodevThrottleDevice.generated.js";
-import * as BlkiodevWeightDevice from "./BlkiodevWeightDevice.generated.js";
-import * as ContainerDeviceMapping from "./ContainerDeviceMapping.generated.js";
-import * as ContainerDeviceRequest from "./ContainerDeviceRequest.generated.js";
-import * as UnitsUlimit from "./UnitsUlimit.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as BlkiodevThrottleDevice from "./BlkiodevThrottleDevice.generated.ts";
+import * as BlkiodevWeightDevice from "./BlkiodevWeightDevice.generated.ts";
+import * as ContainerDeviceMapping from "./ContainerDeviceMapping.generated.ts";
+import * as ContainerDeviceRequest from "./ContainerDeviceRequest.generated.ts";
+import * as UnitsUlimit from "./UnitsUlimit.generated.ts";
 
 export class ContainerResources extends Schema.Class<ContainerResources>("ContainerResources")(
     {
-        CpuShares: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
-        ),
-        Memory: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
-        ),
-        NanoCpus: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
-        ),
-        CgroupParent: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        BlkioWeight: EffectSchemas.Number.U16.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.U16.make(0))
-        ),
-        BlkioWeightDevice: Schema.NullOr(Schema.Array(Schema.NullOr(BlkiodevWeightDevice.BlkiodevWeightDevice)))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        BlkioDeviceReadBps: Schema.NullOr(Schema.Array(Schema.NullOr(BlkiodevThrottleDevice.BlkiodevThrottleDevice)))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        BlkioDeviceWriteBps: Schema.NullOr(Schema.Array(Schema.NullOr(BlkiodevThrottleDevice.BlkiodevThrottleDevice)))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        BlkioDeviceReadIOps: Schema.NullOr(Schema.Array(Schema.NullOr(BlkiodevThrottleDevice.BlkiodevThrottleDevice)))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        BlkioDeviceWriteIOps: Schema.NullOr(Schema.Array(Schema.NullOr(BlkiodevThrottleDevice.BlkiodevThrottleDevice)))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        CpuPeriod: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
-        ),
-        CpuQuota: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
-        ),
-        CpuRealtimePeriod: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
-        ),
-        CpuRealtimeRuntime: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
+        CpuShares: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        Memory: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        NanoCpus: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        CgroupParent: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        BlkioWeight: MobyNumber.NumberFromWireString.check(
+            Schema.isInt(),
+            Schema.isBetween({ minimum: 0, maximum: 2 ** 16 - 1 })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0))),
+        BlkioWeightDevice: Schema.NullOr(Schema.Array(Schema.NullOr(BlkiodevWeightDevice.BlkiodevWeightDevice))).pipe(
+            Schema.withConstructorDefault(Effect.succeed([]))
         ),
-        CpusetCpus: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        CpusetMems: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        Devices: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerDeviceMapping.ContainerDeviceMapping)))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        DeviceCgroupRules: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        DeviceRequests: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerDeviceRequest.ContainerDeviceRequest)))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        KernelMemory: Schema.optional(EffectSchemas.Number.I64),
-        KernelMemoryTCP: Schema.optional(EffectSchemas.Number.I64),
-        MemoryReservation: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
+        BlkioDeviceReadBps: Schema.NullOr(
+            Schema.Array(Schema.NullOr(BlkiodevThrottleDevice.BlkiodevThrottleDevice))
+        ).pipe(Schema.withConstructorDefault(Effect.succeed([]))),
+        BlkioDeviceWriteBps: Schema.NullOr(
+            Schema.Array(Schema.NullOr(BlkiodevThrottleDevice.BlkiodevThrottleDevice))
+        ).pipe(Schema.withConstructorDefault(Effect.succeed([]))),
+        BlkioDeviceReadIOps: Schema.NullOr(
+            Schema.Array(Schema.NullOr(BlkiodevThrottleDevice.BlkiodevThrottleDevice))
+        ).pipe(Schema.withConstructorDefault(Effect.succeed([]))),
+        BlkioDeviceWriteIOps: Schema.NullOr(
+            Schema.Array(Schema.NullOr(BlkiodevThrottleDevice.BlkiodevThrottleDevice))
+        ).pipe(Schema.withConstructorDefault(Effect.succeed([]))),
+        CpuPeriod: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        CpuQuota: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        CpuRealtimePeriod: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        CpuRealtimeRuntime: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        CpusetCpus: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        CpusetMems: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        Devices: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerDeviceMapping.ContainerDeviceMapping))).pipe(
+            Schema.withConstructorDefault(Effect.succeed([]))
         ),
-        MemorySwap: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
+        DeviceCgroupRules: Schema.NullOr(Schema.Array(Schema.String)).pipe(
+            Schema.withConstructorDefault(Effect.succeed([]))
         ),
-        MemorySwappiness: Schema.NullOr(EffectSchemas.Number.I64)
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(-1n))),
-        OomKillDisable: Schema.NullOr(Schema.Boolean)
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => false)),
-        PidsLimit: Schema.NullOr(EffectSchemas.Number.I64)
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))),
-        Ulimits: Schema.NullOr(Schema.Array(Schema.NullOr(UnitsUlimit.UnitsUlimit)))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        CpuCount: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
+        DeviceRequests: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerDeviceRequest.ContainerDeviceRequest))).pipe(
+            Schema.withConstructorDefault(Effect.succeed([]))
         ),
-        CpuPercent: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
+        KernelMemory: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
         ),
-        IOMaximumIOps: EffectSchemas.Number.U64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.U64.make(0n))
+        KernelMemoryTCP: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
         ),
-        IOMaximumBandwidth: EffectSchemas.Number.U64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.U64.make(0n))
+        MemoryReservation: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        MemorySwap: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        MemorySwappiness: Schema.NullOr(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(-1n))),
+        OomKillDisable: Schema.NullOr(Schema.Boolean).pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        PidsLimit: Schema.NullOr(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        Ulimits: Schema.NullOr(Schema.Array(Schema.NullOr(UnitsUlimit.UnitsUlimit))).pipe(
+            Schema.withConstructorDefault(Effect.succeed([]))
         ),
+        CpuCount: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        CpuPercent: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        IOMaximumIOps: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        IOMaximumBandwidth: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
     },
     {
         identifier: "ContainerResources",

package/src/internal/generated/ContainerRestartPolicy.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 ContainerRestartPolicy extends Schema.Class<ContainerRestartPolicy>("ContainerRestartPolicy")(
     {
-        Name: Schema.Literal("no", "always", "on-failure", "unless-stopped"),
-        MaximumRetryCount: EffectSchemas.Number.I64,
+        Name: Schema.Literals(["no", "always", "on-failure", "unless-stopped"]),
+        MaximumRetryCount: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
     },
     {
         identifier: "ContainerRestartPolicy",

package/src/internal/generated/ContainerState.generated.ts

@@ -1,21 +1,26 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as ContainerHealth from "./ContainerHealth.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as ContainerHealth from "./ContainerHealth.generated.ts";
 
 export class ContainerState extends Schema.Class<ContainerState>("ContainerState")(
     {
-        Status: Schema.Literal("created", "restarting", "running", "removing", "paused", "exited", "dead"),
+        Status: Schema.Literals(["created", "restarting", "running", "removing", "paused", "exited", "dead"]),
         Running: Schema.Boolean,
         Paused: Schema.Boolean,
         Restarting: Schema.Boolean,
         OOMKilled: Schema.Boolean,
         Dead: Schema.Boolean,
-        Pid: EffectSchemas.Number.I64,
-        ExitCode: EffectSchemas.Number.I64,
+        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 })
+        ),
         Error: Schema.String,
         StartedAt: Schema.String,
         FinishedAt: Schema.String,
-        Health: Schema.optionalWith(ContainerHealth.ContainerHealth, { nullable: true }),
+        Health: Schema.optional(Schema.NullOr(ContainerHealth.ContainerHealth)),
     },
     {
         identifier: "ContainerState",

package/src/internal/generated/ContainerStatsResponse.generated.ts

@@ -1,11 +1,12 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as ContainerBlkioStats from "./ContainerBlkioStats.generated.js";
-import * as ContainerCPUStats from "./ContainerCPUStats.generated.js";
-import * as ContainerMemoryStats from "./ContainerMemoryStats.generated.js";
-import * as ContainerNetworkStats from "./ContainerNetworkStats.generated.js";
-import * as ContainerPidsStats from "./ContainerPidsStats.generated.js";
-import * as ContainerStorageStats from "./ContainerStorageStats.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as ContainerBlkioStats from "./ContainerBlkioStats.generated.ts";
+import * as ContainerCPUStats from "./ContainerCPUStats.generated.ts";
+import * as ContainerMemoryStats from "./ContainerMemoryStats.generated.ts";
+import * as ContainerNetworkStats from "./ContainerNetworkStats.generated.ts";
+import * as ContainerPidsStats from "./ContainerPidsStats.generated.ts";
+import * as ContainerStorageStats from "./ContainerStorageStats.generated.ts";
 
 export class ContainerStatsResponse extends Schema.Class<ContainerStatsResponse>("ContainerStatsResponse")(
     {
@@ -13,16 +14,18 @@ export class ContainerStatsResponse extends Schema.Class<ContainerStatsResponse>
         id: Schema.optional(Schema.String),
         read: Schema.NullOr(Schema.DateFromString),
         preread: Schema.NullOr(Schema.DateFromString),
-        pids_stats: Schema.optionalWith(ContainerPidsStats.ContainerPidsStats, { nullable: true }),
-        blkio_stats: Schema.optionalWith(ContainerBlkioStats.ContainerBlkioStats, { nullable: true }),
-        num_procs: EffectSchemas.Number.U32,
-        storage_stats: Schema.optionalWith(ContainerStorageStats.ContainerStorageStats, { nullable: true }),
-        cpu_stats: Schema.optionalWith(ContainerCPUStats.ContainerCPUStats, { nullable: true }),
-        precpu_stats: Schema.optionalWith(ContainerCPUStats.ContainerCPUStats, { nullable: true }),
-        memory_stats: Schema.optionalWith(ContainerMemoryStats.ContainerMemoryStats, { nullable: true }),
-        networks: Schema.optionalWith(
-            Schema.Record({ key: Schema.String, value: Schema.NullOr(ContainerNetworkStats.ContainerNetworkStats) }),
-            { nullable: true }
+        pids_stats: Schema.optional(Schema.NullOr(ContainerPidsStats.ContainerPidsStats)),
+        blkio_stats: Schema.optional(Schema.NullOr(ContainerBlkioStats.ContainerBlkioStats)),
+        num_procs: MobyNumber.NumberFromWireString.check(
+            Schema.isInt(),
+            Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+        ),
+        storage_stats: Schema.optional(Schema.NullOr(ContainerStorageStats.ContainerStorageStats)),
+        cpu_stats: Schema.optional(Schema.NullOr(ContainerCPUStats.ContainerCPUStats)),
+        precpu_stats: Schema.optional(Schema.NullOr(ContainerCPUStats.ContainerCPUStats)),
+        memory_stats: Schema.optional(Schema.NullOr(ContainerMemoryStats.ContainerMemoryStats)),
+        networks: Schema.optional(
+            Schema.NullOr(Schema.Record(Schema.String, Schema.NullOr(ContainerNetworkStats.ContainerNetworkStats)))
         ),
     },
     {

package/src/internal/generated/ContainerStorageStats.generated.ts

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

package/src/internal/generated/ContainerSummary.generated.ts

@@ -1,30 +1,40 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as ContainerMountPoint from "./ContainerMountPoint.generated.js";
-import * as ContainerNetworkSettingsSummary from "./ContainerNetworkSettingsSummary.generated.js";
-import * as ContainerPort from "./ContainerPort.generated.js";
-import * as V1Descriptor from "./V1Descriptor.generated.js";
+
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as MobyNumber from "../schemas/number.ts";
+import * as ContainerMountPoint from "./ContainerMountPoint.generated.ts";
+import * as ContainerNetworkSettingsSummary from "./ContainerNetworkSettingsSummary.generated.ts";
+import * as ContainerPort from "./ContainerPort.generated.ts";
+import * as V1Descriptor from "./V1Descriptor.generated.ts";
 
 export class ContainerSummary extends Schema.Class<ContainerSummary>("ContainerSummary")(
     {
-        Id: Schema.String,
+        Id: MobyIdentifiers.ContainerIdentifier,
         Names: Schema.NullOr(Schema.Array(Schema.String)),
         Image: Schema.String,
-        ImageID: Schema.String,
-        ImageManifestDescriptor: Schema.optionalWith(V1Descriptor.V1Descriptor, { nullable: true }),
+        ImageID: MobyIdentifiers.ImageIdentifier,
+        ImageManifestDescriptor: Schema.optional(Schema.NullOr(V1Descriptor.V1Descriptor)),
         Command: Schema.String,
-        Created: EffectSchemas.Number.I64,
+        Created: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         Ports: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerPort.ContainerPort))),
-        SizeRw: Schema.optional(EffectSchemas.Number.I64),
-        SizeRootFs: Schema.optional(EffectSchemas.Number.I64),
-        Labels: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
+        SizeRw: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        SizeRootFs: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        Labels: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
         State: Schema.String,
         Status: Schema.String,
         HostConfig: Schema.Struct({
             NetworkMode: Schema.optional(Schema.String),
-            Annotations: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), {
-                nullable: true,
-            }),
+            Annotations: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
         }),
         NetworkSettings: Schema.NullOr(ContainerNetworkSettingsSummary.ContainerNetworkSettingsSummary),
         Mounts: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerMountPoint.ContainerMountPoint))),

package/src/internal/generated/ContainerThrottlingData.generated.ts

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

package/src/internal/generated/ContainerWaitResponse.generated.ts

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

package/src/internal/generated/EventsActor.generated.ts

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

package/src/internal/generated/EventsMessage.generated.ts

@@ -1,13 +1,14 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as EventsActor from "./EventsActor.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as EventsActor from "./EventsActor.generated.ts";
 
 export class EventsMessage extends Schema.Class<EventsMessage>("EventsMessage")(
     {
         status: Schema.optional(Schema.String),
         id: Schema.optional(Schema.String),
         from: Schema.optional(Schema.String),
-        Type: Schema.Literal(
+        Type: Schema.Literals([
             "builder",
             "config",
             "container",
@@ -18,9 +19,9 @@ export class EventsMessage extends Schema.Class<EventsMessage>("EventsMessage")(
             "plugin",
             "secret",
             "service",
-            "volume"
-        ),
-        Action: Schema.Literal(
+            "volume",
+        ]),
+        Action: Schema.Literals([
             "create",
             "start",
             "restart",
@@ -67,12 +68,20 @@ export class EventsMessage extends Schema.Class<EventsMessage>("EventsMessage")(
             "health_status",
             "health_status: running",
             "health_status: healthy",
-            "health_status: unhealthy"
-        ),
+            "health_status: unhealthy",
+        ]),
         Actor: Schema.NullOr(EventsActor.EventsActor),
         scope: Schema.optional(Schema.String),
-        time: Schema.optional(EffectSchemas.Number.I64),
-        timeNano: Schema.optional(EffectSchemas.Number.I64),
+        time: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        timeNano: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
     },
     {
         identifier: "EventsMessage",

package/src/internal/generated/ImageAttestationProperties.generated.ts

@@ -1,4 +1,5 @@
 import * as Schema from "effect/Schema";
+
 import * as MobyIdentifiers from "../schemas/id.ts";
 
 export class ImageAttestationProperties extends Schema.Class<ImageAttestationProperties>("ImageAttestationProperties")(

package/src/internal/generated/ImageHistoryResponseItem.generated.ts

@@ -1,13 +1,19 @@
-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 ImageHistoryResponseItem extends Schema.Class<ImageHistoryResponseItem>("ImageHistoryResponseItem")(
     {
         Comment: Schema.String,
-        Created: EffectSchemas.Number.I64,
+        Created: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         CreatedBy: Schema.String,
-        Id: Schema.String,
-        Size: EffectSchemas.Number.I64,
+        Id: MobyIdentifiers.ImageIdentifier,
+        Size: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         Tags: Schema.NullOr(Schema.Array(Schema.String)),
     },
     {

package/src/internal/generated/ImageImageProperties.generated.ts

@@ -1,12 +1,15 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as V1Platform from "./V1Platform.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as V1Platform from "./V1Platform.generated.ts";
 
 export class ImageImageProperties extends Schema.Class<ImageImageProperties>("ImageImageProperties")(
     {
         Platform: Schema.NullOr(V1Platform.V1Platform),
         Size: Schema.Struct({
-            Unpacked: EffectSchemas.Number.I64,
+            Unpacked: MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            ),
         }),
         Containers: Schema.NullOr(Schema.Array(Schema.String)),
     },

package/src/internal/generated/ImageInspectResponse.generated.ts

@@ -1,40 +1,50 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
+
 import * as MobyIdentifiers from "../schemas/id.ts";
-import * as ContainerConfig from "./ContainerConfig.generated.js";
-import * as ImageManifestSummary from "./ImageManifestSummary.generated.js";
-import * as ImageMetadata from "./ImageMetadata.generated.js";
-import * as ImageRootFS from "./ImageRootFS.generated.js";
-import * as StorageDriverData from "./StorageDriverData.generated.js";
-import * as V1Descriptor from "./V1Descriptor.generated.js";
-import * as V1DockerOCIImageConfig from "./V1DockerOCIImageConfig.generated.js";
+import * as MobyNumber from "../schemas/number.ts";
+import * as ContainerConfig from "./ContainerConfig.generated.ts";
+import * as ImageManifestSummary from "./ImageManifestSummary.generated.ts";
+import * as ImageMetadata from "./ImageMetadata.generated.ts";
+import * as ImageRootFS from "./ImageRootFS.generated.ts";
+import * as StorageDriverData from "./StorageDriverData.generated.ts";
+import * as V1Descriptor from "./V1Descriptor.generated.ts";
+import * as V1DockerOCIImageConfig from "./V1DockerOCIImageConfig.generated.ts";
 
 export class ImageInspectResponse extends Schema.Class<ImageInspectResponse>("ImageInspectResponse")(
     {
-        Id: Schema.String,
+        Id: MobyIdentifiers.ImageIdentifier,
         RepoTags: Schema.NullOr(Schema.Array(Schema.String)),
         RepoDigests: Schema.NullOr(Schema.Array(MobyIdentifiers.Digest)),
-        Parent: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        // optional for docker.io/library/docker:dind-rootless (omitted since docker v29)
+        Parent: Schema.optional(Schema.String),
         Comment: Schema.String,
         Created: Schema.optional(Schema.String),
         Container: Schema.optional(Schema.String),
-        ContainerConfig: Schema.optionalWith(ContainerConfig.ContainerConfig, { nullable: true }),
-        DockerVersion: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
-        Author: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        ContainerConfig: Schema.optional(Schema.NullOr(ContainerConfig.ContainerConfig)),
+        // optional for docker.io/library/docker:dind-rootless (omitted since docker v29)
+        DockerVersion: Schema.optional(Schema.String),
+        Author: Schema.optional(Schema.String),
         Config: Schema.NullOr(V1DockerOCIImageConfig.V1DockerOCIImageConfig),
         Architecture: Schema.String,
         Variant: Schema.optional(Schema.String),
         Os: Schema.String,
         OsVersion: Schema.optional(Schema.String),
-        Size: EffectSchemas.Number.I64,
-        VirtualSize: Schema.optional(EffectSchemas.Number.I64),
-        GraphDriver: Schema.NullishOr(StorageDriverData.StorageDriverData), // optional for docker.io/library/docker:26-dind-rootless
+        Size: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        VirtualSize: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        // optional for docker.io/library/docker:dind-rootless (omitted since docker v29)
+        GraphDriver: Schema.optional(Schema.NullOr(StorageDriverData.StorageDriverData)),
         RootFS: Schema.NullOr(ImageRootFS.ImageRootFS),
         Metadata: Schema.NullOr(ImageMetadata.ImageMetadata),
-        Descriptor: Schema.optionalWith(V1Descriptor.V1Descriptor, { nullable: true }),
-        Manifests: Schema.optionalWith(Schema.Array(Schema.NullOr(ImageManifestSummary.ImageManifestSummary)), {
-            nullable: true,
-        }),
+        Descriptor: Schema.optional(Schema.NullOr(V1Descriptor.V1Descriptor)),
+        Manifests: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(ImageManifestSummary.ImageManifestSummary)))
+        ),
     },
     {
         identifier: "ImageInspectResponse",