the-moby-effect 1.45.0-alpha.2 → 1.45.0-alpha.21

package/src/generated/ContainerHostConfig.generated.ts

@@ -0,0 +1,181 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+import * as ContainerLogConfig from "./ContainerLogConfig.generated.js";
+import * as ContainerResources from "./ContainerResources.generated.js";
+import * as ContainerRestartPolicy from "./ContainerRestartPolicy.generated.js";
+import * as Mount from "./Mount.generated.js";
+
+export class ContainerHostConfig extends Schema.Class<ContainerHostConfig>("ContainerHostConfig")(
+    {
+        // Applicable to all platforms
+        /** List of volume bindings for this container */
+        Binds: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** File (path) where the containerId is written */
+        ContainerIDFile: Schema.String,
+
+        /** Configuration of the logs for this container */
+        LogConfig: Schema.NullOr(ContainerLogConfig.ContainerLogConfig),
+
+        /** Network mode to use for the container */
+        NetworkMode: Schema.Literal("default", "none", "host", "bridge", "nat"),
+
+        /** Port mapping between the exposed port (container) and the host */
+        PortBindings: Schema.NullOr(MobySchemas.PortSchemas.PortMap),
+
+        /** Restart policy to be used for the container */
+        RestartPolicy: Schema.NullOr(ContainerRestartPolicy.ContainerRestartPolicy),
+
+        /** Automatically remove container when it exits */
+        AutoRemove: Schema.Boolean,
+
+        /** Name of the volume driver used to mount volumes */
+        VolumeDriver: Schema.String,
+
+        /** List of volumes to take from other container */
+        VolumesFrom: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** Initial console size (height,width) */
+        ConsoleSize: Schema.Array(MobySchemas.UInt64).pipe(Schema.itemsCount(2)),
+
+        /**
+         * Arbitrary non-identifying metadata attached to container and provided
+         * to the runtime
+         */
+        Annotations: Schema.optionalWith(
+            Schema.Record({
+                key: Schema.String,
+                value: Schema.String,
+            }),
+            { nullable: true }
+        ),
+
+        // Applicable to UNIX platforms
+        /** List of kernel capabilities to add to the container */
+        CapAdd: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** List of kernel capabilities to remove from the container */
+        CapDrop: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** Cgroup namespace mode to use for the container */
+        CgroupnsMode: Schema.Literal("", "private", "host"),
+
+        /** List of DNS servers for the container to use */
+        Dns: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** List of DNS search domains */
+        DnsOptions: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** List of DNS search domains */
+        DnsSearch: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** List of extra hosts */
+        ExtraHosts: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** List of additional groups that the container process will run as */
+        GroupAdd: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** IPC namespace to use for the container */
+        IpcMode: Schema.Literal("none", "host", "container", "private", "shareable"),
+
+        /** Cgroup to use for the container */
+        Cgroup: Schema.String,
+
+        /** List of links (in the name:alias form) */
+        Links: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** Container preference for OOM-killing */
+        OomScoreAdj: MobySchemas.Int64,
+
+        /** PID namespace to use for the container */
+        PidMode: Schema.String,
+
+        /** Is the container in privileged mode */
+        Privileged: Schema.Boolean,
+
+        /** Should docker publish all exposed port for the container */
+        PublishAllPorts: Schema.Boolean,
+
+        /** Is the container root filesystem in read-only */
+        ReadonlyRootfs: Schema.Boolean,
+
+        /**
+         * List of string values to customize labels for MLS systems, such as
+         * SELinux.
+         */
+        SecurityOpt: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** Storage driver options per container. */
+        StorageOpt: Schema.optionalWith(
+            Schema.Record({
+                key: Schema.String,
+                value: Schema.String,
+            }),
+            { nullable: true }
+        ),
+
+        /** List of tmpfs (mounts) used for the container */
+        Tmpfs: Schema.optionalWith(
+            Schema.Record({
+                key: Schema.String,
+                value: Schema.String,
+            }),
+            { nullable: true }
+        ),
+
+        /** UTS namespace to use for the container */
+        UTSMode: Schema.String,
+
+        /** The user namespace to use for the container */
+        UsernsMode: Schema.String,
+
+        /** Total shm memory usage */
+        ShmSize: MobySchemas.Int64,
+
+        /** List of Namespaced sysctls used for the container */
+        Sysctls: Schema.optionalWith(
+            Schema.Record({
+                key: Schema.String,
+                value: Schema.String,
+            }),
+            { nullable: true }
+        ),
+
+        /** Runtime to use with this container */
+        Runtime: Schema.optional(Schema.String),
+
+        // Applicable to Windows
+        /** Isolation technology of the container (e.g. default, hyperv) */
+        Isolation: Schema.Literal("default", "process", "hyperv", ""),
+
+        // Contains container's resources (cgroups, ulimits)
+        ...ContainerResources.ContainerResources.fields,
+
+        /** Mounts specs used by the container */
+        Mounts: Schema.optionalWith(Schema.Array(Schema.NullOr(Mount.Mount)), { nullable: true }),
+
+        /**
+         * MaskedPaths is the list of paths to be masked inside the container
+         * (this overrides the default set of paths)
+         */
+        MaskedPaths: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /**
+         * ReadonlyPaths is the list of paths to be set as read-only inside the
+         * container (this overrides the default set of paths)
+         */
+        ReadonlyPaths: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /**
+         * Run a custom init inside the container, if null, use the daemon's
+         * configured settings
+         */
+        Init: Schema.optionalWith(Schema.Boolean, { nullable: true }),
+    },
+    {
+        identifier: "ContainerHostConfig",
+        title: "container.HostConfig",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/container/hostconfig.go#L420-L480",
+    }
+) {}

package/src/generated/ContainerInspectResponse.generated.ts

@@ -0,0 +1,44 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+import * as ContainerConfig from "./ContainerConfig.generated.js";
+import * as ContainerHostConfig from "./ContainerHostConfig.generated.js";
+import * as ContainerNode from "./ContainerNode.generated.js";
+import * as ContainerState from "./ContainerState.generated.js";
+import * as GraphDriverData from "./GraphDriverData.generated.js";
+import * as MountPoint from "./MountPoint.generated.js";
+import * as NetworkSettings from "./NetworkSettings.generated.js";
+
+export class ContainerInspectResponse extends Schema.Class<ContainerInspectResponse>("ContainerInspectResponse")(
+    {
+        Id: Schema.String,
+        Created: Schema.String,
+        Path: Schema.String,
+        Args: Schema.NullOr(Schema.Array(Schema.String)),
+        State: Schema.NullOr(ContainerState.ContainerState),
+        Image: Schema.String,
+        ResolvConfPath: Schema.String,
+        HostnamePath: Schema.String,
+        HostsPath: Schema.String,
+        LogPath: Schema.String,
+        Node: Schema.optionalWith(ContainerNode.ContainerNode, { nullable: true }),
+        Name: Schema.String,
+        RestartCount: MobySchemas.Int64,
+        Driver: Schema.String,
+        Platform: Schema.String,
+        MountLabel: Schema.String,
+        ProcessLabel: Schema.String,
+        AppArmorProfile: Schema.String,
+        ExecIDs: Schema.NullOr(Schema.Array(Schema.String)),
+        HostConfig: Schema.NullOr(ContainerHostConfig.ContainerHostConfig),
+        GraphDriver: Schema.NullOr(GraphDriverData.GraphDriverData),
+        SizeRw: Schema.optionalWith(MobySchemas.Int64, { nullable: true }),
+        SizeRootFs: Schema.optionalWith(MobySchemas.Int64, { nullable: true }),
+        Mounts: Schema.NullOr(Schema.Array(Schema.NullOr(MountPoint.MountPoint))),
+        Config: Schema.NullOr(ContainerConfig.ContainerConfig),
+        NetworkSettings: Schema.NullOr(NetworkSettings.NetworkSettings),
+    },
+    {
+        identifier: "ContainerInspectResponse",
+        title: "types.ContainerJSON",
+    }
+) {}

package/src/generated/ContainerJSONBase.generated.ts

@@ -0,0 +1,38 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+import * as ContainerHostConfig from "./ContainerHostConfig.generated.js";
+import * as ContainerNode from "./ContainerNode.generated.js";
+import * as ContainerState from "./ContainerState.generated.js";
+import * as GraphDriverData from "./GraphDriverData.generated.js";
+
+export class ContainerJSONBase extends Schema.Class<ContainerJSONBase>("ContainerJSONBase")(
+    {
+        Id: Schema.String,
+        Created: Schema.String,
+        Path: Schema.String,
+        Args: Schema.NullOr(Schema.Array(Schema.String)),
+        State: Schema.NullOr(ContainerState.ContainerState),
+        Image: Schema.String,
+        ResolvConfPath: Schema.String,
+        HostnamePath: Schema.String,
+        HostsPath: Schema.String,
+        LogPath: Schema.String,
+        Node: Schema.optionalWith(ContainerNode.ContainerNode, { nullable: true }),
+        Name: Schema.String,
+        RestartCount: MobySchemas.Int64,
+        Driver: Schema.String,
+        Platform: Schema.String,
+        MountLabel: Schema.String,
+        ProcessLabel: Schema.String,
+        AppArmorProfile: Schema.String,
+        ExecIDs: Schema.NullOr(Schema.Array(Schema.String)),
+        HostConfig: Schema.NullOr(ContainerHostConfig.ContainerHostConfig),
+        GraphDriver: Schema.NullOr(GraphDriverData.GraphDriverData),
+        SizeRw: Schema.optionalWith(MobySchemas.Int64, { nullable: true }),
+        SizeRootFs: Schema.optionalWith(MobySchemas.Int64, { nullable: true }),
+    },
+    {
+        identifier: "ContainerJSONBase",
+        title: "types.ContainerJSONBase",
+    }
+) {}

package/src/generated/ContainerListResponseItem.generated.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+import * as MountPoint from "./MountPoint.generated.js";
+import * as Port from "./Port.generated.js";
+import * as SummaryNetworkSettings from "./SummaryNetworkSettings.generated.js";
+
+export class ContainerListResponseItem extends Schema.Class<ContainerListResponseItem>("ContainerListResponseItem")(
+    {
+        Id: Schema.String,
+        Names: Schema.NullOr(Schema.Array(Schema.String)),
+        Image: Schema.String,
+        ImageID: Schema.String,
+        Command: Schema.String,
+        Created: MobySchemas.Int64,
+        Ports: Schema.NullOr(Schema.Array(Schema.NullOr(Port.Port))),
+        SizeRw: Schema.optional(MobySchemas.Int64),
+        SizeRootFs: Schema.optional(MobySchemas.Int64),
+        Labels: Schema.NullOr(
+            Schema.Record({
+                key: Schema.String,
+                value: 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 }
+            ),
+        }),
+        NetworkSettings: Schema.NullOr(SummaryNetworkSettings.SummaryNetworkSettings),
+        Mounts: Schema.NullOr(Schema.Array(Schema.NullOr(MountPoint.MountPoint))),
+    },
+    {
+        identifier: "ContainerListResponseItem",
+        title: "types.Container",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/types.go#L140-L161",
+    }
+) {}

package/src/generated/ContainerLogConfig.generated.ts

@@ -0,0 +1,19 @@
+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,
+            })
+        ),
+    },
+    {
+        identifier: "ContainerLogConfig",
+        title: "container.LogConfig",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/container/hostconfig.go#L357-L361",
+    }
+) {}

package/src/generated/ContainerLogsOptions.generated.ts

@@ -0,0 +1,20 @@
+import * as Schema from "effect/Schema";
+
+export class ContainerLogsOptions extends Schema.Class<ContainerLogsOptions>("ContainerLogsOptions")(
+    {
+        ShowStdout: Schema.Boolean,
+        ShowStderr: Schema.Boolean,
+        Since: Schema.String,
+        Until: Schema.String,
+        Timestamps: Schema.Boolean,
+        Follow: Schema.Boolean,
+        Tail: Schema.String,
+        Details: Schema.Boolean,
+    },
+    {
+        identifier: "ContainerLogsOptions",
+        title: "container.LogsOptions",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/container/options.go#L57-L67",
+    }
+) {}

package/src/generated/ContainerMemoryStats.generated.ts

@@ -0,0 +1,27 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+
+export class ContainerMemoryStats extends Schema.Class<ContainerMemoryStats>("ContainerMemoryStats")(
+    {
+        usage: Schema.optional(MobySchemas.UInt64),
+        max_usage: Schema.optional(MobySchemas.UInt64),
+        stats: Schema.optionalWith(
+            Schema.Record({
+                key: Schema.String,
+                value: MobySchemas.UInt64,
+            }),
+            { nullable: true }
+        ),
+        failcnt: Schema.optional(MobySchemas.UInt64),
+        limit: Schema.optional(MobySchemas.UInt64),
+        commitbytes: Schema.optional(MobySchemas.UInt64),
+        commitpeakbytes: Schema.optional(MobySchemas.UInt64),
+        privateworkingset: Schema.optional(MobySchemas.UInt64),
+    },
+    {
+        identifier: "ContainerMemoryStats",
+        title: "container.MemoryStats",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/container/stats.go#L55-L80",
+    }
+) {}

package/src/generated/ContainerNetworkStats.generated.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+
+export class ContainerNetworkStats extends Schema.Class<ContainerNetworkStats>("ContainerNetworkStats")(
+    {
+        /** Bytes received. Windows and Linux. */
+        rx_bytes: MobySchemas.UInt64,
+
+        /** Packets received. Windows and Linux. */
+        rx_packets: MobySchemas.UInt64,
+
+        /** Received errors. Not used on Windows. */
+        rx_errors: MobySchemas.UInt64,
+
+        /** Incoming packets dropped. Windows and Linux. */
+        rx_dropped: MobySchemas.UInt64,
+
+        /** Bytes sent. Windows and Linux. */
+        tx_bytes: MobySchemas.UInt64,
+
+        /** Packets sent. Windows and Linux. */
+        tx_packets: MobySchemas.UInt64,
+
+        /** Sent errors. Not used on Windows. */
+        tx_errors: MobySchemas.UInt64,
+
+        /** Outgoing packets dropped. Windows and Linux. */
+        tx_dropped: MobySchemas.UInt64,
+
+        /** Endpoint ID. Not used on Linux. */
+        endpoint_id: Schema.optional(Schema.String),
+
+        /** Instance ID. Not used on Linux. */
+        instance_id: Schema.optional(Schema.String),
+    },
+    {
+        identifier: "ContainerNetworkStats",
+        title: "container.NetworkStats",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/container/stats.go#L115-L139",
+    }
+) {}

package/src/generated/ContainerNode.generated.ts

@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+
+export class ContainerNode extends Schema.Class<ContainerNode>("ContainerNode")(
+    {
+        ID: Schema.String,
+        IP: Schema.String,
+        Addr: Schema.String,
+        Name: Schema.String,
+        Cpus: MobySchemas.Int64,
+        Memory: MobySchemas.Int64,
+        Labels: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
+    },
+    {
+        identifier: "ContainerNode",
+        title: "types.ContainerNode",
+    }
+) {}

package/src/generated/ContainerPathStat.generated.ts

@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+
+export class ContainerPathStat extends Schema.Class<ContainerPathStat>("ContainerPathStat")(
+    {
+        name: Schema.String,
+        size: MobySchemas.Int64,
+        mode: MobySchemas.UInt32,
+        mtime: Schema.NullOr(Schema.DateFromString),
+        linkTarget: Schema.String,
+    },
+    {
+        identifier: "ContainerPathStat",
+        title: "container.PathStat",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/container/container.go#L16-L25",
+    }
+) {}

package/src/generated/ContainerPidsStats.generated.ts

@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+
+export class ContainerPidsStats extends Schema.Class<ContainerPidsStats>("ContainerPidsStats")(
+    {
+        /** Current is the number of pids in the cgroup */
+        current: Schema.optional(MobySchemas.UInt64),
+
+        /** Limit is the hard limit on the number of pids in the cgroup. */
+        limit: Schema.optional(MobySchemas.UInt64),
+    },
+    {
+        identifier: "ContainerPidsStats",
+        title: "container.PidsStats",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/container/stats.go#L141-L148",
+    }
+) {}

package/src/generated/ContainerPruneResponse.generated.ts

@@ -0,0 +1,15 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+
+export class ContainerPruneResponse extends Schema.Class<ContainerPruneResponse>("ContainerPruneResponse")(
+    {
+        ContainersDeleted: Schema.NullOr(Schema.Array(Schema.String)),
+        SpaceReclaimed: MobySchemas.UInt64,
+    },
+    {
+        identifier: "ContainerPruneResponse",
+        title: "container.PruneReport",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/container/container.go#L9-L14",
+    }
+) {}

package/src/generated/ContainerResources.generated.ts

@@ -0,0 +1,110 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+import * as ContainerDeviceMapping from "./ContainerDeviceMapping.generated.js";
+import * as ContainerDeviceRequest from "./ContainerDeviceRequest.generated.js";
+import * as ContainerUlimit from "./ContainerUlimit.generated.js";
+import * as ThrottleDevice from "./ThrottleDevice.generated.js";
+import * as WeightDevice from "./WeightDevice.generated.js";
+
+export class ContainerResources extends Schema.Class<ContainerResources>("ContainerResources")(
+    {
+        // Applicable to all platforms
+        /** CPU shares (relative weight vs. other containers) */
+        CpuShares: MobySchemas.Int64,
+
+        /** Memory limit (in bytes) */
+        Memory: MobySchemas.Int64,
+
+        /** CPU quota */
+        NanoCpus: MobySchemas.Int64,
+
+        // Applicable to UNIX platforms
+        /** Parent cgroup. */
+        CgroupParent: Schema.String,
+
+        /** Block IO weight (relative weight vs. other containers) */
+        BlkioWeight: MobySchemas.UInt16,
+
+        BlkioWeightDevice: Schema.NullOr(Schema.Array(Schema.NullOr(WeightDevice.WeightDevice))),
+        BlkioDeviceReadBps: Schema.NullOr(Schema.Array(Schema.NullOr(ThrottleDevice.ThrottleDevice))),
+        BlkioDeviceWriteBps: Schema.NullOr(Schema.Array(Schema.NullOr(ThrottleDevice.ThrottleDevice))),
+        BlkioDeviceReadIOps: Schema.NullOr(Schema.Array(Schema.NullOr(ThrottleDevice.ThrottleDevice))),
+        BlkioDeviceWriteIOps: Schema.NullOr(Schema.Array(Schema.NullOr(ThrottleDevice.ThrottleDevice))),
+
+        /** CPU CFS (Completely Fair Scheduler) period */
+        CpuPeriod: MobySchemas.Int64,
+
+        /** CPU CFS (Completely Fair Scheduler) quota */
+        CpuQuota: MobySchemas.Int64,
+
+        /** CPU real-time period */
+        CpuRealtimePeriod: MobySchemas.Int64,
+
+        /** CPU real-time runtime */
+        CpuRealtimeRuntime: MobySchemas.Int64,
+
+        /** CpusetCpus 0-2, 0,1 */
+        CpusetCpus: Schema.String,
+
+        /** CpusetMems 0-2, 0,1 */
+        CpusetMems: Schema.String,
+
+        /** List of devices to map inside the container */
+        Devices: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerDeviceMapping.ContainerDeviceMapping))),
+
+        /** List of rule to be added to the device cgroup */
+        DeviceCgroupRules: Schema.NullOr(Schema.Array(Schema.String)),
+
+        /** List of device requests for device drivers */
+        DeviceRequests: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerDeviceRequest.ContainerDeviceRequest))),
+
+        /**
+         * KernelMemory specifies the kernel memory limit (in bytes) for the
+         * container. Deprecated: kernel 5.4 deprecated kmem.limit_in_bytes.
+         */
+        KernelMemory: Schema.optional(MobySchemas.Int64),
+
+        /** Hard limit for kernel TCP buffer memory (in bytes) */
+        KernelMemoryTCP: Schema.optional(MobySchemas.Int64),
+
+        /** Memory soft limit (in bytes) */
+        MemoryReservation: MobySchemas.Int64,
+
+        /** Total memory usage (memory + swap); set `-1` to enable unlimited swap */
+        MemorySwap: MobySchemas.Int64,
+
+        /** Tuning container memory swappiness behaviour */
+        MemorySwappiness: Schema.NullOr(MobySchemas.Int64),
+
+        /** Whether to disable OOM Killer or not */
+        OomKillDisable: Schema.NullOr(Schema.Boolean),
+
+        /**
+         * Setting PIDs limit for a container; Set `0` or `-1` for unlimited, or
+         * `null` to not change.
+         */
+        PidsLimit: Schema.NullOr(MobySchemas.Int64),
+
+        /** List of ulimits to be set in the container */
+        Ulimits: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerUlimit.ContainerUlimit))),
+
+        // Applicable to Windows
+        /** Cpu count */
+        CpuCount: MobySchemas.Int64,
+
+        /** CPU percent */
+        CpuPercent: MobySchemas.Int64,
+
+        /** Maximum IOps for the container system drive */
+        IOMaximumIOps: MobySchemas.UInt64,
+
+        /** Maximum IO in bytes per second for the container system drive */
+        IOMaximumBandwidth: MobySchemas.UInt64,
+    },
+    {
+        identifier: "ContainerResources",
+        title: "container.Resources",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/container/hostconfig.go#L369-L410",
+    }
+) {}

package/src/generated/ContainerRestartPolicy.generated.ts

@@ -0,0 +1,15 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+
+export class ContainerRestartPolicy extends Schema.Class<ContainerRestartPolicy>("ContainerRestartPolicy")(
+    {
+        Name: Schema.Literal("no", "always", "unless-stopped", "on-failure"),
+        MaximumRetryCount: MobySchemas.Int64,
+    },
+    {
+        identifier: "ContainerRestartPolicy",
+        title: "container.RestartPolicy",
+        documentation:
+            "https://github.com/moby/moby/blob/a21b1a2d12e2c01542cb191eb526d7bfad0641e3/api/types/container/hostconfig.go#L274-L278",
+    }
+) {}

package/src/generated/ContainerState.generated.ts

@@ -0,0 +1,24 @@
+import * as Schema from "effect/Schema";
+import * as MobySchemas from "../schemas/index.js";
+import * as Health from "./Health.generated.js";
+
+export class ContainerState extends Schema.Class<ContainerState>("ContainerState")(
+    {
+        Status: Schema.String,
+        Running: Schema.Boolean,
+        Paused: Schema.Boolean,
+        Restarting: Schema.Boolean,
+        OOMKilled: Schema.Boolean,
+        Dead: Schema.Boolean,
+        Pid: MobySchemas.Int64,
+        ExitCode: MobySchemas.Int64,
+        Error: Schema.String,
+        StartedAt: Schema.String,
+        FinishedAt: Schema.String,
+        Health: Schema.optionalWith(Health.Health, { nullable: true }),
+    },
+    {
+        identifier: "ContainerState",
+        title: "types.ContainerState",
+    }
+) {}