the-moby-effect 1.51.6 → 1.54.1

package/src/internal/generated/ContainerExecOptions.generated.ts

@@ -1,23 +1,30 @@
-import * as EffectSchemas from "effect-schemas";
+import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerExecOptions extends Schema.Class<ContainerExecOptions>("ContainerExecOptions")(
     {
-        User: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        Privileged: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        Tty: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        ConsoleSize: Schema.optionalWith(Schema.Array(EffectSchemas.Number.U64).pipe(Schema.itemsCount(2)), {
-            nullable: true,
-        }),
+        User: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        Privileged: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        Tty: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        ConsoleSize: Schema.optional(
+            Schema.NullOr(
+                Schema.Array(
+                    MobyNumber.BigIntFromWireString.check(
+                        Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+                    )
+                ).check(Schema.isLengthBetween(2, 2))
+            )
+        ),
         AttachStdin: Schema.Boolean,
         AttachStderr: Schema.Boolean,
         AttachStdout: Schema.Boolean,
-        DetachKeys: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        Env: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        WorkingDir: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        Cmd: Schema.Array(Schema.String),
+        DetachKeys: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        Env: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+        WorkingDir: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        Cmd: Schema.NullOr(Schema.Array(Schema.String)),
+        Detach: Schema.Boolean,
     },
     {
         identifier: "ContainerExecOptions",

package/src/internal/generated/ContainerExecStartOptions.generated.ts

@@ -1,13 +1,20 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerExecStartOptions extends Schema.Class<ContainerExecStartOptions>("ContainerExecStartOptions")(
     {
         Detach: Schema.Boolean,
         Tty: Schema.Boolean,
-        ConsoleSize: Schema.optionalWith(Schema.Array(EffectSchemas.Number.U64).pipe(Schema.itemsCount(2)), {
-            nullable: true,
-        }),
+        ConsoleSize: Schema.optional(
+            Schema.NullOr(
+                Schema.Array(
+                    MobyNumber.BigIntFromWireString.check(
+                        Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+                    )
+                ).check(Schema.isLengthBetween(2, 2))
+            )
+        ),
     },
     {
         identifier: "ContainerExecStartOptions",

package/src/internal/generated/ContainerHealth.generated.ts

@@ -1,11 +1,14 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
-import * as ContainerHealthcheckResult from "./ContainerHealthcheckResult.generated.js";
+
+import * as MobyNumber from "../schemas/number.ts";
+import * as ContainerHealthcheckResult from "./ContainerHealthcheckResult.generated.ts";
 
 export class ContainerHealth extends Schema.Class<ContainerHealth>("ContainerHealth")(
     {
-        Status: Schema.Literal("none", "starting", "healthy", "unhealthy"),
-        FailingStreak: EffectSchemas.Number.I64,
+        Status: Schema.Literals(["none", "starting", "healthy", "unhealthy"]),
+        FailingStreak: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         Log: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerHealthcheckResult.ContainerHealthcheckResult))),
     },
     {

package/src/internal/generated/ContainerHealthcheckResult.generated.ts

@@ -1,11 +1,14 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerHealthcheckResult extends Schema.Class<ContainerHealthcheckResult>("ContainerHealthcheckResult")(
     {
         Start: Schema.NullOr(Schema.DateFromString),
         End: Schema.NullOr(Schema.DateFromString),
-        ExitCode: EffectSchemas.Number.I64,
+        ExitCode: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
         Output: Schema.String,
     },
     {

package/src/internal/generated/ContainerHostConfig.generated.ts

@@ -1,120 +1,84 @@
-import * as EffectSchemas from "effect-schemas";
+import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
+
+import * as MobyNumber from "../schemas/number.ts";
 import * as PortSchemas from "../schemas/port.ts";
-import * as ContainerLogConfig from "./ContainerLogConfig.generated.js";
-import * as ContainerResources from "./ContainerResources.generated.js";
-import * as ContainerRestartPolicy from "./ContainerRestartPolicy.generated.js";
-import * as MountMount from "./MountMount.generated.js";
+import * as ContainerLogConfig from "./ContainerLogConfig.generated.ts";
+import * as ContainerResources from "./ContainerResources.generated.ts";
+import * as ContainerRestartPolicy from "./ContainerRestartPolicy.generated.ts";
+import * as MountMount from "./MountMount.generated.ts";
 
 export class ContainerHostConfig extends Schema.Class<ContainerHostConfig>("ContainerHostConfig")(
     {
-        Binds: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        ContainerIDFile: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        LogConfig: Schema.NullOr(ContainerLogConfig.ContainerLogConfig)
-            .pipe(Schema.propertySignature)
-            .pipe(
-                Schema.withConstructorDefault(
-                    () => new ContainerLogConfig.ContainerLogConfig({ Type: "json-file", Config: null })
-                )
-            ),
-        NetworkMode: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "default")),
-        PortBindings: Schema.NullOr(PortSchemas.PortMap)
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        RestartPolicy: Schema.NullOr(ContainerRestartPolicy.ContainerRestartPolicy)
-            .pipe(Schema.propertySignature)
-            .pipe(
-                Schema.withConstructorDefault(
-                    () =>
-                        new ContainerRestartPolicy.ContainerRestartPolicy({
-                            Name: "no",
-                            MaximumRetryCount: EffectSchemas.Number.I64.make(0n),
-                        })
-                )
-            ),
-        AutoRemove: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        VolumeDriver: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        VolumesFrom: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        ConsoleSize: Schema.Array(EffectSchemas.Number.U64)
-            .pipe(Schema.itemsCount(2))
-            .pipe(Schema.propertySignature)
-            .pipe(
-                Schema.withConstructorDefault(() => [
-                    EffectSchemas.Number.U64.make(0n),
-                    EffectSchemas.Number.U64.make(0n),
-                ])
-            ),
-        Annotations: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), {
-            nullable: true,
-        }),
-        CapAdd: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        CapDrop: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        CgroupnsMode: Schema.Literal("", "private", "host")
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => "")),
-        Dns: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        DnsOptions: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        DnsSearch: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => [])),
-        ExtraHosts: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        GroupAdd: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        IpcMode: Schema.Literal("", "none", "host", "container", "private", "shareable")
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => "")),
-        Cgroup: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        Links: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        OomScoreAdj: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
+        Binds: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+        ContainerIDFile: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        LogConfig: Schema.NullOr(ContainerLogConfig.ContainerLogConfig).pipe(
+            Schema.withConstructorDefault(
+                Effect.succeed(new ContainerLogConfig.ContainerLogConfig({ Type: "json-file", Config: null }))
+            )
+        ),
+        NetworkMode: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed("default"))),
+        PortBindings: Schema.NullOr(PortSchemas.PortMap).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+        RestartPolicy: Schema.NullOr(ContainerRestartPolicy.ContainerRestartPolicy).pipe(
+            Schema.withConstructorDefault(
+                Effect.succeed(new ContainerRestartPolicy.ContainerRestartPolicy({ Name: "no", MaximumRetryCount: 0n }))
+            )
+        ),
+        AutoRemove: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        VolumeDriver: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        VolumesFrom: Schema.NullOr(Schema.Array(Schema.String)).pipe(
+            Schema.withConstructorDefault(Effect.succeed(null))
+        ),
+        ConsoleSize: Schema.Array(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        )
+            .check(Schema.isLengthBetween(2, 2))
+            .pipe(Schema.withConstructorDefault(Effect.succeed([0n, 0n]))),
+        Annotations: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
+        CapAdd: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+        CapDrop: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+        CgroupnsMode: Schema.Literals(["", "private", "host"]).pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        Dns: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed([]))),
+        DnsOptions: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed([]))),
+        DnsSearch: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed([]))),
+        ExtraHosts: Schema.NullOr(Schema.Array(Schema.String)).pipe(
+            Schema.withConstructorDefault(Effect.succeed(null))
         ),
-        PidMode: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        Privileged: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        PublishAllPorts: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        ReadonlyRootfs: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
-        SecurityOpt: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        StorageOpt: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), {
-            nullable: true,
-        }),
-        Tmpfs: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
-        UTSMode: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        UsernsMode: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "")),
-        ShmSize: EffectSchemas.Number.I64.pipe(Schema.propertySignature).pipe(
-            Schema.withConstructorDefault(() => EffectSchemas.Number.I64.make(0n))
+        GroupAdd: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+        IpcMode: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        Cgroup: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        Links: Schema.NullOr(Schema.Array(Schema.String)).pipe(Schema.withConstructorDefault(Effect.succeed(null))),
+        OomScoreAdj: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        PidMode: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        Privileged: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        PublishAllPorts: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        ReadonlyRootfs: Schema.Boolean.pipe(Schema.withConstructorDefault(Effect.succeed(false))),
+        SecurityOpt: Schema.NullOr(Schema.Array(Schema.String)).pipe(
+            Schema.withConstructorDefault(Effect.succeed(null))
         ),
-        Sysctls: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
+        StorageOpt: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
+        Tmpfs: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
+        UTSMode: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        UsernsMode: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed(""))),
+        ShmSize: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ).pipe(Schema.withConstructorDefault(Effect.succeed(0n))),
+        Sysctls: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.String))),
         Runtime: Schema.optional(Schema.String),
-        Isolation: Schema.Literal("", "default", "process", "hyperv")
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => "")),
+        Isolation: Schema.Literals(["", "default", "process", "hyperv"]).pipe(
+            Schema.withConstructorDefault(Effect.succeed(""))
+        ),
         ...ContainerResources.ContainerResources.fields,
-        Mounts: Schema.optionalWith(Schema.Array(Schema.NullOr(MountMount.MountMount)), { nullable: true }),
-        MaskedPaths: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        ReadonlyPaths: Schema.NullOr(Schema.Array(Schema.String))
-            .pipe(Schema.propertySignature)
-            .pipe(Schema.withConstructorDefault(() => null)),
-        Init: Schema.optionalWith(Schema.Boolean, { nullable: true }),
+        Mounts: Schema.optional(Schema.NullOr(Schema.Array(Schema.NullOr(MountMount.MountMount)))),
+        MaskedPaths: Schema.NullOr(Schema.Array(Schema.String)).pipe(
+            Schema.withConstructorDefault(Effect.succeed(null))
+        ),
+        ReadonlyPaths: Schema.NullOr(Schema.Array(Schema.String)).pipe(
+            Schema.withConstructorDefault(Effect.succeed(null))
+        ),
+        Init: Schema.optional(Schema.NullOr(Schema.Boolean)),
     },
     {
         identifier: "ContainerHostConfig",

package/src/internal/generated/ContainerInspectResponse.generated.ts

@@ -1,9 +1,10 @@
 import * as Schema from "effect/Schema";
-import * as ContainerConfig from "./ContainerConfig.generated.js";
-import * as ContainerContainerJSONBase from "./ContainerContainerJSONBase.generated.js";
-import * as ContainerMountPoint from "./ContainerMountPoint.generated.js";
-import * as ContainerNetworkSettings from "./ContainerNetworkSettings.generated.js";
-import * as V1Descriptor from "./V1Descriptor.generated.js";
+
+import * as ContainerConfig from "./ContainerConfig.generated.ts";
+import * as ContainerContainerJSONBase from "./ContainerContainerJSONBase.generated.ts";
+import * as ContainerMountPoint from "./ContainerMountPoint.generated.ts";
+import * as ContainerNetworkSettings from "./ContainerNetworkSettings.generated.ts";
+import * as V1Descriptor from "./V1Descriptor.generated.ts";
 
 export class ContainerInspectResponse extends Schema.Class<ContainerInspectResponse>("ContainerInspectResponse")(
     {
@@ -11,7 +12,7 @@ export class ContainerInspectResponse extends Schema.Class<ContainerInspectRespo
         Mounts: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerMountPoint.ContainerMountPoint))),
         Config: Schema.NullOr(ContainerConfig.ContainerConfig),
         NetworkSettings: Schema.NullOr(ContainerNetworkSettings.ContainerNetworkSettings),
-        ImageManifestDescriptor: Schema.optionalWith(V1Descriptor.V1Descriptor, { nullable: true }),
+        ImageManifestDescriptor: Schema.optional(Schema.NullOr(V1Descriptor.V1Descriptor)),
     },
     {
         identifier: "ContainerInspectResponse",

package/src/internal/generated/ContainerLogConfig.generated.ts

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

package/src/internal/generated/ContainerMemoryStats.generated.ts

@@ -1,18 +1,40 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerMemoryStats extends Schema.Class<ContainerMemoryStats>("ContainerMemoryStats")(
     {
-        usage: Schema.optional(EffectSchemas.Number.U64),
-        max_usage: Schema.optional(EffectSchemas.Number.U64),
-        stats: Schema.optionalWith(Schema.Record({ key: Schema.String, value: EffectSchemas.Number.U64 }), {
-            nullable: true,
-        }),
-        failcnt: Schema.optional(EffectSchemas.Number.U64),
-        limit: Schema.optional(EffectSchemas.Number.U64),
-        commitbytes: Schema.optional(EffectSchemas.Number.U64),
-        commitpeakbytes: Schema.optional(EffectSchemas.Number.U64),
-        privateworkingset: Schema.optional(EffectSchemas.Number.U64),
+        usage: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
+        max_usage: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
+        stats: Schema.optional(
+            Schema.NullOr(
+                Schema.Record(
+                    Schema.String,
+                    MobyNumber.BigIntFromWireString.check(
+                        Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+                    )
+                )
+            )
+        ),
+        failcnt: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
+        limit: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
+        commitbytes: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
+        commitpeakbytes: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
+        privateworkingset: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
     },
     {
         identifier: "ContainerMemoryStats",

package/src/internal/generated/ContainerMountPoint.generated.ts

@@ -2,14 +2,14 @@ import * as Schema from "effect/Schema";
 
 export class ContainerMountPoint extends Schema.Class<ContainerMountPoint>("ContainerMountPoint")(
     {
-        Type: Schema.optional(Schema.Literal("bind", "volume", "tmpfs", "npipe", "cluster", "image")),
+        Type: Schema.optional(Schema.Literals(["bind", "volume", "tmpfs", "npipe", "cluster", "image"])),
         Name: Schema.optional(Schema.String),
         Source: Schema.String,
         Destination: Schema.String,
         Driver: Schema.optional(Schema.String),
         Mode: Schema.String,
         RW: Schema.Boolean,
-        Propagation: Schema.Literal("rprivate", "private", "rshared", "shared", "rslave", "slave", ""),
+        Propagation: Schema.Literals(["", "rprivate", "private", "rshared", "shared", "rslave", "slave"]),
     },
     {
         identifier: "ContainerMountPoint",

package/src/internal/generated/ContainerNetworkSettings.generated.ts

@@ -1,14 +1,15 @@
 import * as Schema from "effect/Schema";
-import * as ContainerDefaultNetworkSettings from "./ContainerDefaultNetworkSettings.generated.js";
-import * as ContainerNetworkSettingsBase from "./ContainerNetworkSettingsBase.generated.js";
-import * as NetworkEndpointSettings from "./NetworkEndpointSettings.generated.js";
+
+import * as ContainerDefaultNetworkSettings from "./ContainerDefaultNetworkSettings.generated.ts";
+import * as ContainerNetworkSettingsBase from "./ContainerNetworkSettingsBase.generated.ts";
+import * as NetworkEndpointSettings from "./NetworkEndpointSettings.generated.ts";
 
 export class ContainerNetworkSettings extends Schema.Class<ContainerNetworkSettings>("ContainerNetworkSettings")(
     {
         ...ContainerNetworkSettingsBase.ContainerNetworkSettingsBase.fields,
         ...ContainerDefaultNetworkSettings.ContainerDefaultNetworkSettings.fields,
         Networks: Schema.NullOr(
-            Schema.Record({ key: Schema.String, value: Schema.NullOr(NetworkEndpointSettings.NetworkEndpointSettings) })
+            Schema.Record(Schema.String, Schema.NullOr(NetworkEndpointSettings.NetworkEndpointSettings))
         ),
     },
     {

package/src/internal/generated/ContainerNetworkSettingsBase.generated.ts

@@ -1,21 +1,30 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
+
+import * as MobyNumber from "../schemas/number.ts";
 import * as PortSchemas from "../schemas/port.ts";
-import * as NetworkAddress from "./NetworkAddress.generated.js";
+import * as NetworkAddress from "./NetworkAddress.generated.ts";
 
 export class ContainerNetworkSettingsBase extends Schema.Class<ContainerNetworkSettingsBase>(
     "ContainerNetworkSettingsBase"
 )(
     {
-        Bridge: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        Bridge: Schema.optional(Schema.String),
         SandboxID: Schema.String,
         SandboxKey: Schema.String,
         Ports: Schema.NullOr(PortSchemas.PortMap),
-        HairpinMode: Schema.optional(Schema.Boolean), // optional for docker.io/library/docker:26-dind-rootless
-        LinkLocalIPv6Address: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
-        LinkLocalIPv6PrefixLen: Schema.optional(EffectSchemas.Number.I64), // optional for docker.io/library/docker:26-dind-rootless
-        SecondaryIPAddresses: Schema.NullishOr(Schema.Array(Schema.NullOr(NetworkAddress.NetworkAddress))), // optional for docker.io/library/docker:26-dind-rootless
-        SecondaryIPv6Addresses: Schema.NullishOr(Schema.Array(Schema.NullOr(NetworkAddress.NetworkAddress))), // optional for docker.io/library/docker:26-dind-rootless
+        HairpinMode: Schema.optional(Schema.Boolean),
+        LinkLocalIPv6Address: Schema.optional(Schema.String),
+        LinkLocalIPv6PrefixLen: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(
+                Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+            )
+        ),
+        SecondaryIPAddresses: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(NetworkAddress.NetworkAddress)))
+        ),
+        SecondaryIPv6Addresses: Schema.optional(
+            Schema.NullOr(Schema.Array(Schema.NullOr(NetworkAddress.NetworkAddress)))
+        ),
     },
     {
         identifier: "ContainerNetworkSettingsBase",

package/src/internal/generated/ContainerNetworkSettingsSummary.generated.ts

@@ -1,12 +1,13 @@
 import * as Schema from "effect/Schema";
-import * as NetworkEndpointSettings from "./NetworkEndpointSettings.generated.js";
+
+import * as NetworkEndpointSettings from "./NetworkEndpointSettings.generated.ts";
 
 export class ContainerNetworkSettingsSummary extends Schema.Class<ContainerNetworkSettingsSummary>(
     "ContainerNetworkSettingsSummary"
 )(
     {
         Networks: Schema.NullOr(
-            Schema.Record({ key: Schema.String, value: Schema.NullOr(NetworkEndpointSettings.NetworkEndpointSettings) })
+            Schema.Record(Schema.String, Schema.NullOr(NetworkEndpointSettings.NetworkEndpointSettings))
         ),
     },
     {

package/src/internal/generated/ContainerNetworkStats.generated.ts

@@ -1,16 +1,33 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerNetworkStats extends Schema.Class<ContainerNetworkStats>("ContainerNetworkStats")(
     {
-        rx_bytes: EffectSchemas.Number.U64,
-        rx_packets: EffectSchemas.Number.U64,
-        rx_errors: EffectSchemas.Number.U64,
-        rx_dropped: EffectSchemas.Number.U64,
-        tx_bytes: EffectSchemas.Number.U64,
-        tx_packets: EffectSchemas.Number.U64,
-        tx_errors: EffectSchemas.Number.U64,
-        tx_dropped: EffectSchemas.Number.U64,
+        rx_bytes: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        rx_packets: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        rx_errors: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        rx_dropped: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        tx_bytes: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        tx_packets: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        tx_errors: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
+        tx_dropped: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })
+        ),
         endpoint_id: Schema.optional(Schema.String),
         instance_id: Schema.optional(Schema.String),
     },

package/src/internal/generated/ContainerPathStat.generated.ts

@@ -1,11 +1,17 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerPathStat extends Schema.Class<ContainerPathStat>("ContainerPathStat")(
     {
         name: Schema.String,
-        size: EffectSchemas.Number.I64,
-        mode: EffectSchemas.Number.U32,
+        size: MobyNumber.BigIntFromWireString.check(
+            Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n })
+        ),
+        mode: MobyNumber.NumberFromWireString.check(
+            Schema.isInt(),
+            Schema.isBetween({ minimum: 0, maximum: 2 ** 32 - 1 })
+        ),
         mtime: Schema.NullOr(Schema.DateFromString),
         linkTarget: Schema.String,
     },

package/src/internal/generated/ContainerPidsStats.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 ContainerPidsStats extends Schema.Class<ContainerPidsStats>("ContainerPidsStats")(
     {
-        current: Schema.optional(EffectSchemas.Number.U64),
-        limit: Schema.optional(EffectSchemas.Number.U64),
+        current: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
+        limit: Schema.optional(
+            MobyNumber.BigIntFromWireString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }))
+        ),
     },
     {
         identifier: "ContainerPidsStats",

package/src/internal/generated/ContainerPort.generated.ts

@@ -1,11 +1,20 @@
-import * as EffectSchemas from "effect-schemas";
 import * as Schema from "effect/Schema";
 
+import * as MobyNumber from "../schemas/number.ts";
+
 export class ContainerPort extends Schema.Class<ContainerPort>("ContainerPort")(
     {
         IP: Schema.optional(Schema.String),
-        PrivatePort: EffectSchemas.Number.U16,
-        PublicPort: Schema.optional(EffectSchemas.Number.U16),
+        PrivatePort: MobyNumber.NumberFromWireString.check(
+            Schema.isInt(),
+            Schema.isBetween({ minimum: 0, maximum: 2 ** 16 - 1 })
+        ),
+        PublicPort: Schema.optional(
+            MobyNumber.NumberFromWireString.check(
+                Schema.isInt(),
+                Schema.isBetween({ minimum: 0, maximum: 2 ** 16 - 1 })
+            )
+        ),
         Type: Schema.String,
     },
     {