the-moby-effect 1.51.6 → 1.54.1

package/src/internal/generated/ImageManifestSummary.generated.ts

@@ -1,8 +1,9 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as ImageAttestationProperties from "./ImageAttestationProperties.generated.js";
-import * as ImageImageProperties from "./ImageImageProperties.generated.js";
-import * as V1Descriptor from "./V1Descriptor.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as ImageAttestationProperties from "./ImageAttestationProperties.generated.ts";
+import * as ImageImageProperties from "./ImageImageProperties.generated.ts";
+import * as V1Descriptor from "./V1Descriptor.generated.ts";
 
 export class ImageManifestSummary extends Schema.Class<ImageManifestSummary>("ImageManifestSummary")(
     {
@@ -10,12 +11,16 @@ export class ImageManifestSummary extends Schema.Class<ImageManifestSummary>("Im
         Descriptor: Schema.NullOr(V1Descriptor.V1Descriptor),
         Available: Schema.Boolean,
         Size: Schema.Struct({
-            Content: EffectSchemas.Number.I64,
-            Total: EffectSchemas.Number.I64,
+            Content: MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            ),
+            Total: MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            ),
         }),
-        Kind: Schema.Literal("image", "attestation", "unknown"),
-        ImageData: Schema.optionalWith(ImageImageProperties.ImageImageProperties, { nullable: true }),
-        AttestationData: Schema.optionalWith(ImageAttestationProperties.ImageAttestationProperties, { nullable: true }),
+        Kind: Schema.Literals(["image", "attestation", "unknown"]),
+        ImageData: Schema.optional(Schema.NullOr(ImageImageProperties.ImageImageProperties)),
+        AttestationData: Schema.optional(Schema.NullOr(ImageAttestationProperties.ImageAttestationProperties)),
     },
     {
         identifier: "ImageManifestSummary",

package/src/internal/generated/ImageMetadata.generated.ts

@@ -2,7 +2,7 @@ import * as Schema from "effect/Schema";
 
 export class ImageMetadata extends Schema.Class<ImageMetadata>("ImageMetadata")(
     {
-        LastTagTime: Schema.optionalWith(Schema.DateFromString, { nullable: true }),
+        LastTagTime: Schema.optional(Schema.NullOr(Schema.DateFromString)),
     },
     {
         identifier: "ImageMetadata",

package/src/internal/generated/ImageRootFS.generated.ts

@@ -3,7 +3,7 @@ import * as Schema from "effect/Schema";
 export class ImageRootFS extends Schema.Class<ImageRootFS>("ImageRootFS")(
     {
         Type: Schema.optional(Schema.String),
-        Layers: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        Layers: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
     },
     {
         identifier: "ImageRootFS",

package/src/internal/generated/ImageSummary.generated.ts

@@ -1,25 +1,38 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
+
 import * as MobyIdentifiers from "../schemas/id.ts";
-import * as ImageManifestSummary from "./ImageManifestSummary.generated.js";
-import * as V1Descriptor from "./V1Descriptor.generated.js";
+import * as MobyNumber from "../schemas/number.ts";
+import * as ImageManifestSummary from "./ImageManifestSummary.generated.ts";
+import * as V1Descriptor from "./V1Descriptor.generated.ts";
 
 export class ImageSummary extends Schema.Class<ImageSummary>("ImageSummary")(
     {
-        Containers: EffectSchemas.Number.I64,
-        Created: EffectSchemas.Number.I64,
-        Id: Schema.String,
-        Labels: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
+        Containers: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        Created: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        Id: MobyIdentifiers.ImageIdentifier,
+        Labels: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
         ParentId: Schema.String,
-        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)))
+        ),
         RepoDigests: Schema.NullOr(Schema.Array(MobyIdentifiers.Digest)),
         RepoTags: Schema.NullOr(Schema.Array(Schema.String)),
-        SharedSize: EffectSchemas.Number.I64,
-        Size: EffectSchemas.Number.I64,
-        VirtualSize: Schema.optional(EffectSchemas.Number.I64),
+        SharedSize: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        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 })
+            )
+        ),
     },
     {
         identifier: "ImageSummary",

package/src/internal/generated/JSONMessage.generated.ts

@@ -1,21 +1,30 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as JsonmessageJSONError from "./JsonmessageJSONError.generated.js";
-import * as JsonmessageJSONProgress from "./JsonmessageJSONProgress.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as JsonmessageJSONError from "./JsonmessageJSONError.generated.ts";
+import * as JsonmessageJSONProgress from "./JsonmessageJSONProgress.generated.ts";
 
 export class JSONMessage extends Schema.Class<JSONMessage>("JSONMessage")(
     {
         stream: Schema.optional(Schema.String),
         status: Schema.optional(Schema.String),
-        progressDetail: Schema.optionalWith(JsonmessageJSONProgress.JsonmessageJSONProgress, { nullable: true }),
+        progressDetail: Schema.optional(Schema.NullOr(JsonmessageJSONProgress.JsonmessageJSONProgress)),
         progress: Schema.optional(Schema.String),
         id: Schema.optional(Schema.String),
         from: Schema.optional(Schema.String),
-        time: Schema.optional(EffectSchemas.Number.I64),
-        timeNano: Schema.optional(EffectSchemas.Number.I64),
-        errorDetail: Schema.optionalWith(JsonmessageJSONError.JsonmessageJSONError, { nullable: true }),
+        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 })
+            )
+        ),
+        errorDetail: Schema.optional(Schema.NullOr(JsonmessageJSONError.JsonmessageJSONError)),
         error: Schema.optional(Schema.String),
-        // aux: Schema.optionalWith(Schema.Array(EffectSchemas.Number.U8), { nullable: true }),
+        aux: Schema.optional(Schema.NullOr(Schema.Unknown)),
     },
     {
         identifier: "JSONMessage",

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

package/src/internal/generated/JsonmessageJSONProgress.generated.ts

@@ -1,11 +1,24 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class JsonmessageJSONProgress extends Schema.Class<JsonmessageJSONProgress>("JsonmessageJSONProgress")(
     {
-        current: Schema.optional(EffectSchemas.Number.I64),
-        total: Schema.optional(EffectSchemas.Number.I64),
-        start: Schema.optional(EffectSchemas.Number.I64),
+        current: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        total: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        start: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
         hidecounts: Schema.optional(Schema.Boolean),
         units: Schema.optional(Schema.String),
     },

package/src/internal/generated/MountBindOptions.generated.ts

@@ -2,7 +2,7 @@ import * as Schema from "effect/Schema";
 
 export class MountBindOptions extends Schema.Class<MountBindOptions>("MountBindOptions")(
     {
-        Propagation: Schema.optional(Schema.Literal("rprivate", "private", "rshared", "shared", "rslave", "slave")),
+        Propagation: Schema.optional(Schema.Literals(["rprivate", "private", "rshared", "shared", "rslave", "slave"])),
         NonRecursive: Schema.optional(Schema.Boolean),
         CreateMountpoint: Schema.optional(Schema.Boolean),
         ReadOnlyNonRecursive: Schema.optional(Schema.Boolean),

package/src/internal/generated/MountDriver.generated.ts

@@ -3,7 +3,7 @@ import * as Schema from "effect/Schema";
 export class MountDriver extends Schema.Class<MountDriver>("MountDriver")(
     {
         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: "MountDriver",

package/src/internal/generated/MountMount.generated.ts

@@ -1,22 +1,23 @@
 import * as Schema from "effect/Schema";
-import * as MountBindOptions from "./MountBindOptions.generated.js";
-import * as MountClusterOptions from "./MountClusterOptions.generated.js";
-import * as MountImageOptions from "./MountImageOptions.generated.js";
-import * as MountTmpfsOptions from "./MountTmpfsOptions.generated.js";
-import * as MountVolumeOptions from "./MountVolumeOptions.generated.js";
+
+import * as MountBindOptions from "./MountBindOptions.generated.ts";
+import * as MountClusterOptions from "./MountClusterOptions.generated.ts";
+import * as MountImageOptions from "./MountImageOptions.generated.ts";
+import * as MountTmpfsOptions from "./MountTmpfsOptions.generated.ts";
+import * as MountVolumeOptions from "./MountVolumeOptions.generated.ts";
 
 export class MountMount extends Schema.Class<MountMount>("MountMount")(
     {
-        Type: Schema.optional(Schema.Literal("bind", "volume", "tmpfs", "npipe", "cluster", "image")),
+        Type: Schema.optional(Schema.Literals(["bind", "volume", "tmpfs", "npipe", "cluster", "image"])),
         Source: Schema.optional(Schema.String),
         Target: Schema.optional(Schema.String),
         ReadOnly: Schema.optional(Schema.Boolean),
-        Consistency: Schema.optional(Schema.Literal("consistent", "cached", "delegated", "default")),
-        BindOptions: Schema.optionalWith(MountBindOptions.MountBindOptions, { nullable: true }),
-        VolumeOptions: Schema.optionalWith(MountVolumeOptions.MountVolumeOptions, { nullable: true }),
-        ImageOptions: Schema.optionalWith(MountImageOptions.MountImageOptions, { nullable: true }),
-        TmpfsOptions: Schema.optionalWith(MountTmpfsOptions.MountTmpfsOptions, { nullable: true }),
-        ClusterOptions: Schema.optionalWith(MountClusterOptions.MountClusterOptions, { nullable: true }),
+        Consistency: Schema.optional(Schema.Literals(["consistent", "cached", "delegated", "default"])),
+        BindOptions: Schema.optional(Schema.NullOr(MountBindOptions.MountBindOptions)),
+        VolumeOptions: Schema.optional(Schema.NullOr(MountVolumeOptions.MountVolumeOptions)),
+        ImageOptions: Schema.optional(Schema.NullOr(MountImageOptions.MountImageOptions)),
+        TmpfsOptions: Schema.optional(Schema.NullOr(MountTmpfsOptions.MountTmpfsOptions)),
+        ClusterOptions: Schema.optional(Schema.NullOr(MountClusterOptions.MountClusterOptions)),
     },
     {
         identifier: "MountMount",

package/src/internal/generated/MountTmpfsOptions.generated.ts

@@ -1,11 +1,21 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class MountTmpfsOptions extends Schema.Class<MountTmpfsOptions>("MountTmpfsOptions")(
     {
-        SizeBytes: Schema.optional(EffectSchemas.Number.I64),
-        Mode: Schema.optional(EffectSchemas.Number.U32),
-        Options: Schema.optionalWith(Schema.Array(Schema.NullOr(Schema.Array(Schema.String))), { nullable: true }),
+        SizeBytes: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        Mode: Schema.optional(
+            MobyNumber.NumberFromWireString.check(
+                Schema.isInt(),
+                Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+            )
+        ),
+        Options: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(Schema.Array(Schema.String))))),
     },
     {
         identifier: "MountTmpfsOptions",

package/src/internal/generated/MountVolumeOptions.generated.ts

@@ -1,12 +1,13 @@
 import * as Schema from "effect/Schema";
-import * as MountDriver from "./MountDriver.generated.js";
+
+import * as MountDriver from "./MountDriver.generated.ts";
 
 export class MountVolumeOptions extends Schema.Class<MountVolumeOptions>("MountVolumeOptions")(
     {
         NoCopy: Schema.optional(Schema.Boolean),
-        Labels: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
+        Labels: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
         Subpath: Schema.optional(Schema.String),
-        DriverConfig: Schema.optionalWith(MountDriver.MountDriver, { nullable: true }),
+        DriverConfig: Schema.optional(Schema.NullOr(MountDriver.MountDriver)),
     },
     {
         identifier: "MountVolumeOptions",

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

package/src/internal/generated/NetworkConnectOptions.generated.ts

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

package/src/internal/generated/NetworkCreateOptions.generated.ts

@@ -1,21 +1,23 @@
+import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import * as NetworkConfigReference from "./NetworkConfigReference.generated.js";
-import * as NetworkIPAM from "./NetworkIPAM.generated.js";
+
+import * as NetworkConfigReference from "./NetworkConfigReference.generated.ts";
+import * as NetworkIPAM from "./NetworkIPAM.generated.ts";
 
 export class NetworkCreateOptions extends Schema.Class<NetworkCreateOptions>("NetworkCreateOptions")(
     {
-        Driver: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "bridge")),
-        Scope: Schema.optionalWith(Schema.String, { nullable: true }),
-        EnableIPv4: Schema.optionalWith(Schema.Boolean, { nullable: true }),
-        EnableIPv6: Schema.optionalWith(Schema.Boolean, { nullable: true }),
-        IPAM: Schema.optionalWith(NetworkIPAM.NetworkIPAM, { nullable: true }),
-        Internal: Schema.optionalWith(Schema.Boolean, { nullable: true }),
-        Attachable: Schema.optionalWith(Schema.Boolean, { nullable: true }),
-        Ingress: Schema.optionalWith(Schema.Boolean, { nullable: true }),
-        ConfigOnly: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        ConfigFrom: Schema.optionalWith(NetworkConfigReference.NetworkConfigReference, { nullable: true }),
-        Options: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
-        Labels: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
+        Driver: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed("bridge"))),
+        Scope: Schema.optional(Schema.String),
+        EnableIPv4: Schema.optional(Schema.NullOr(Schema.Boolean)),
+        EnableIPv6: Schema.optional(Schema.NullOr(Schema.Boolean)),
+        IPAM: Schema.optional(Schema.NullOr(NetworkIPAM.NetworkIPAM)),
+        Internal: Schema.optional(Schema.Boolean),
+        Attachable: Schema.optional(Schema.Boolean),
+        Ingress: Schema.optional(Schema.Boolean),
+        ConfigOnly: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        ConfigFrom: Schema.optional(Schema.NullOr(NetworkConfigReference.NetworkConfigReference)),
+        Options: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
+        Labels: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
     },
     {
         identifier: "NetworkCreateOptions",

package/src/internal/generated/NetworkCreateRequest.generated.ts

@@ -1,11 +1,12 @@
 import * as Schema from "effect/Schema";
-import * as NetworkCreateOptions from "./NetworkCreateOptions.generated.js";
+
+import * as NetworkCreateOptions from "./NetworkCreateOptions.generated.ts";
 
 export class NetworkCreateRequest extends Schema.Class<NetworkCreateRequest>("NetworkCreateRequest")(
     {
         ...NetworkCreateOptions.NetworkCreateOptions.fields,
         Name: Schema.String,
-        CheckDuplicate: Schema.optionalWith(Schema.Boolean, { nullable: true }),
+        CheckDuplicate: Schema.optional(Schema.NullOr(Schema.Boolean)),
     },
     {
         identifier: "NetworkCreateRequest",

package/src/internal/generated/NetworkEndpointIPAMConfig.generated.ts

@@ -4,7 +4,7 @@ export class NetworkEndpointIPAMConfig extends Schema.Class<NetworkEndpointIPAMC
     {
         IPv4Address: Schema.optional(Schema.String),
         IPv6Address: Schema.optional(Schema.String),
-        LinkLocalIPs: Schema.optionalWith(Schema.Array(Schema.String), { nullable: true }),
+        LinkLocalIPs: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
     },
     {
         identifier: "NetworkEndpointIPAMConfig",

package/src/internal/generated/NetworkEndpointSettings.generated.ts

@@ -1,6 +1,7 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as NetworkEndpointIPAMConfig from "./NetworkEndpointIPAMConfig.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as NetworkEndpointIPAMConfig from "./NetworkEndpointIPAMConfig.generated.ts";
 
 export class NetworkEndpointSettings extends Schema.Class<NetworkEndpointSettings>("NetworkEndpointSettings")(
     {
@@ -8,20 +9,25 @@ export class NetworkEndpointSettings extends Schema.Class<NetworkEndpointSetting
         Links: Schema.NullOr(Schema.Array(Schema.String)),
         Aliases: Schema.NullOr(Schema.Array(Schema.String)),
         MacAddress: Schema.String,
-        DriverOpts: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
-
-        // For backwards compatibility, GwPriority is optional
-        // GwPriority: EffectSchemas.Number.I64,
-        GwPriority: Schema.optional(EffectSchemas.Number.I64),
-
+        DriverOpts: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
+        // optional for docker.io/library/docker:26-dind-rootless and 27 (added in docker v28)
+        GwPriority: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
         NetworkID: Schema.String,
         EndpointID: Schema.String,
         Gateway: Schema.String,
         IPAddress: Schema.String,
-        IPPrefixLen: EffectSchemas.Number.I64,
+        IPPrefixLen: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         IPv6Gateway: Schema.String,
         GlobalIPv6Address: Schema.String,
-        GlobalIPv6PrefixLen: EffectSchemas.Number.I64,
+        GlobalIPv6PrefixLen: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         DNSNames: Schema.NullOr(Schema.Array(Schema.String)),
     },
     {

package/src/internal/generated/NetworkIPAM.generated.ts

@@ -1,10 +1,11 @@
 import * as Schema from "effect/Schema";
-import * as NetworkIPAMConfig from "./NetworkIPAMConfig.generated.js";
+
+import * as NetworkIPAMConfig from "./NetworkIPAMConfig.generated.ts";
 
 export class NetworkIPAM extends Schema.Class<NetworkIPAM>("NetworkIPAM")(
     {
         Driver: Schema.String,
-        Options: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
+        Options: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
         Config: Schema.NullOr(Schema.Array(Schema.NullOr(NetworkIPAMConfig.NetworkIPAMConfig))),
     },
     {

package/src/internal/generated/NetworkIPAMConfig.generated.ts

@@ -5,9 +5,7 @@ export class NetworkIPAMConfig extends Schema.Class<NetworkIPAMConfig>("NetworkI
         Subnet: Schema.optional(Schema.String),
         IPRange: Schema.optional(Schema.String),
         Gateway: Schema.optional(Schema.String),
-        AuxiliaryAddresses: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), {
-            nullable: true,
-        }),
+        AuxiliaryAddresses: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
     },
     {
         identifier: "NetworkIPAMConfig",

package/src/internal/generated/NetworkInspect.generated.ts

@@ -1,18 +1,21 @@
 import * as Schema from "effect/Schema";
-import * as NetworkConfigReference from "./NetworkConfigReference.generated.js";
-import * as NetworkEndpointResource from "./NetworkEndpointResource.generated.js";
-import * as NetworkIPAM from "./NetworkIPAM.generated.js";
-import * as NetworkPeerInfo from "./NetworkPeerInfo.generated.js";
-import * as NetworkServiceInfo from "./NetworkServiceInfo.generated.js";
+
+import * as MobyIdentifiers from "../schemas/id.ts";
+import * as NetworkConfigReference from "./NetworkConfigReference.generated.ts";
+import * as NetworkEndpointResource from "./NetworkEndpointResource.generated.ts";
+import * as NetworkIPAM from "./NetworkIPAM.generated.ts";
+import * as NetworkPeerInfo from "./NetworkPeerInfo.generated.ts";
+import * as NetworkServiceInfo from "./NetworkServiceInfo.generated.ts";
 
 export class NetworkInspect extends Schema.Class<NetworkInspect>("NetworkInspect")(
     {
         Name: Schema.String,
-        Id: Schema.String,
+        Id: MobyIdentifiers.NetworkIdentifier,
         Created: Schema.NullOr(Schema.DateFromString),
         Scope: Schema.String,
         Driver: Schema.String,
-        EnableIPv4: Schema.optional(Schema.Boolean), // optional for docker.io/library/docker:27-dind-rootless
+        // optional for docker.io/library/docker:26-dind-rootless and 27 (added in docker v28)
+        EnableIPv4: Schema.optional(Schema.Boolean),
         EnableIPv6: Schema.Boolean,
         IPAM: Schema.NullOr(NetworkIPAM.NetworkIPAM),
         Internal: Schema.Boolean,
@@ -20,15 +23,15 @@ export class NetworkInspect extends Schema.Class<NetworkInspect>("NetworkInspect
         Ingress: Schema.Boolean,
         ConfigFrom: Schema.NullOr(NetworkConfigReference.NetworkConfigReference),
         ConfigOnly: Schema.Boolean,
-        Containers: Schema.NullishOr(
-            Schema.Record({ key: Schema.String, value: Schema.NullOr(NetworkEndpointResource.NetworkEndpointResource) }) // optional for docker.io/library/docker:26-dind-rootless
+        // optional for docker list responses which omit it on some daemon versions
+        Containers: Schema.optional(
+            Schema.NullOr(Schema.Record(Schema.String, Schema.NullOr(NetworkEndpointResource.NetworkEndpointResource)))
         ),
-        Options: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
-        Labels: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
-        Peers: Schema.optionalWith(Schema.Array(Schema.NullOr(NetworkPeerInfo.NetworkPeerInfo)), { nullable: true }),
-        Services: Schema.optionalWith(
-            Schema.Record({ key: Schema.String, value: Schema.NullOr(NetworkServiceInfo.NetworkServiceInfo) }),
-            { nullable: true }
+        Options: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
+        Labels: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
+        Peers: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(NetworkPeerInfo.NetworkPeerInfo)))),
+        Services: Schema.optional(
+            Schema.NullOr(Schema.Record(Schema.String, Schema.NullOr(NetworkServiceInfo.NetworkServiceInfo)))
         ),
     },
     {

package/src/internal/generated/NetworkNetworkingConfig.generated.ts

@@ -1,13 +1,13 @@
+import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import * as NetworkEndpointSettings from "./NetworkEndpointSettings.generated.js";
+
+import * as NetworkEndpointSettings from "./NetworkEndpointSettings.generated.ts";
 
 export class NetworkNetworkingConfig extends Schema.Class<NetworkNetworkingConfig>("NetworkNetworkingConfig")(
     {
         EndpointsConfig: Schema.NullOr(
-            Schema.Record({ key: Schema.String, value: Schema.NullOr(NetworkEndpointSettings.NetworkEndpointSettings) })
-        )
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
+            Schema.Record(Schema.String, Schema.NullOr(NetworkEndpointSettings.NetworkEndpointSettings))
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
     },
     {
         identifier: "NetworkNetworkingConfig",

package/src/internal/generated/NetworkServiceInfo.generated.ts

@@ -1,12 +1,15 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as NetworkTask from "./NetworkTask.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as NetworkTask from "./NetworkTask.generated.ts";
 
 export class NetworkServiceInfo extends Schema.Class<NetworkServiceInfo>("NetworkServiceInfo")(
     {
         VIP: Schema.String,
         Ports: Schema.NullOr(Schema.Array(Schema.String)),
-        LocalLBIndex: EffectSchemas.Number.I64,
+        LocalLBIndex: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         Tasks: Schema.NullOr(Schema.Array(Schema.NullOr(NetworkTask.NetworkTask))),
     },
     {

package/src/internal/generated/NetworkTask.generated.ts

@@ -5,7 +5,7 @@ export class NetworkTask extends Schema.Class<NetworkTask>("NetworkTask")(
         Name: Schema.String,
         EndpointID: Schema.String,
         EndpointIP: Schema.String,
-        Info: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
+        Info: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
     },
     {
         identifier: "NetworkTask",

package/src/internal/generated/RegistryDistributionInspect.generated.ts

@@ -1,6 +1,7 @@
 import * as Schema from "effect/Schema";
-import * as V1Descriptor from "./V1Descriptor.generated.js";
-import * as V1Platform from "./V1Platform.generated.js";
+
+import * as V1Descriptor from "./V1Descriptor.generated.ts";
+import * as V1Platform from "./V1Platform.generated.ts";
 
 export class RegistryDistributionInspect extends Schema.Class<RegistryDistributionInspect>(
     "RegistryDistributionInspect"

package/src/internal/generated/RegistrySearchResult.generated.ts

@@ -1,9 +1,12 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class RegistrySearchResult extends Schema.Class<RegistrySearchResult>("RegistrySearchResult")(
     {
-        star_count: EffectSchemas.Number.I64,
+        star_count: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         is_official: Schema.Boolean,
         name: Schema.String,
         is_automated: Schema.Boolean,