@lakutata/containerd 0.0.0-stage → 3.0.0-beta.1

package/dist/esm/containerd/options/container/ContainerCreateOptions.js

@@ -0,0 +1,235 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * The settings of a container created by {@link Containerd.createContainer}: its image, its process, its mounts, its
+ * networks, its resources and its security. Only `image` is required; the container is created stopped (`start()` it)
+ * as a nerdctl container (`nerdctl ps` lists it), with an OCI runtime specification built as nerdctl builds it. The
+ * component keeps these settings: {@link ContainerdContainer.update} creates the container again with the ones it
+ * changes.
+ *
+ * As with the Docker component, the container joins the default network `bridge` unless `network` or `networks` is
+ * given (here a CNI network, the CNI plugins needed); its ports are published only on a CNI network, and its named volumes are directories the component keeps (not Docker's nor
+ * nerdctl's volumes).
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * await containerd.pullImage({image: 'nginx:1.27'})
+ * const container = await containerd.createContainer({
+ *     image: 'nginx:1.27',
+ *     name: 'web',
+ *     env: {NGINX_PORT: '80'},
+ *     binds: [{hostPath: '/srv/www', containerPath: '/usr/share/nginx/html', rw: false}],
+ *     volumes: [{volumeName: 'web-cache', containerPath: '/var/cache/nginx'}],
+ *     //The default nerdctl network, its port 80 published on the host port 8080
+ *     networks: [{networkName: 'bridge'}],
+ *     ports: [{port: 80, hostPorts: [8080]}],
+ *     memoryLimit: 256 * 1024 * 1024,
+ *     cpus: 0.5,
+ *     restartPolicy: 'unless-stopped'
+ * })
+ * await container.start()
+ * ```
+ */
+export class ContainerCreateOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "image", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "platform", void 0);
+__decorate([
+    Expect(DTO.String().pattern(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/).optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "name", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "hostname", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "cmd", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "entrypoint", void 0);
+__decorate([
+    Expect(DTO.Object().pattern(DTO.String(), DTO.String().allow('')).optional()),
+    __metadata("design:type", Object)
+], ContainerCreateOptions.prototype, "env", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "workingDir", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "user", void 0);
+__decorate([
+    Expect(DTO.Object().pattern(DTO.String(), DTO.String().allow('')).optional()),
+    __metadata("design:type", Object)
+], ContainerCreateOptions.prototype, "labels", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerCreateOptions.prototype, "privileged", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerCreateOptions.prototype, "readonlyRootfs", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "capabilities", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "capabilitiesDrop", void 0);
+__decorate([
+    Expect(DTO.String().optional().default('default')),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "seccompProfile", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Object({
+        hostPath: DTO.String().required(),
+        containerPath: DTO.String().required(),
+        rw: DTO.Boolean().optional().default(true),
+        propagation: DTO.String().valid('private', 'rprivate', 'shared', 'rshared', 'slave', 'rslave').optional()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "binds", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Object({
+        volumeName: DTO.String().pattern(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/).required(),
+        containerPath: DTO.String().required(),
+        readonly: DTO.Boolean().optional()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "volumes", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Object({
+        containerPath: DTO.String().required(),
+        size: DTO.Number().integer().positive().optional(),
+        mode: DTO.String().pattern(/^[0-7]{3,4}$/).optional()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "tmpfs", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Object({
+        hostPath: DTO.String().required(),
+        containerPath: DTO.String().optional(),
+        cgroupPermissions: DTO.String().pattern(/^(?!.*(.).*\1)[rwm]{1,3}$/).optional().default('rwm')
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "devices", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String().pattern(/^[acb] (\*|\d+):(\*|\d+) (?!.*(.).*\3)[rwm]{1,3}$/)).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "deviceCgroupRules", void 0);
+__decorate([
+    Expect(DTO.String().valid('host', 'none').optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "network", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Object({
+        networkName: DTO.String().required(),
+        ip: DTO.String().allow('').ip({ version: 'ipv4' }).optional(),
+        ipv6: DTO.String().allow('').ip({ version: 'ipv6' }).optional()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "networks", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Object({
+        port: DTO.Number().port().required(),
+        type: DTO.String().valid('tcp', 'udp', 'sctp').optional().default('tcp'),
+        hostPorts: DTO.Array(DTO.Number().port()).min(1).required(),
+        hostIP: DTO.String().ip().optional()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "ports", void 0);
+__decorate([
+    Expect(DTO.String().valid('host').optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "pidMode", void 0);
+__decorate([
+    Expect(DTO.String().valid('host').optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "ipcMode", void 0);
+__decorate([
+    Expect(DTO.String().valid('private', 'host').optional().default('private')),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "cgroupns", void 0);
+__decorate([
+    Expect(DTO.Number().integer().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "memoryLimit", void 0);
+__decorate([
+    Expect(DTO.Number().integer().min(-1).optional().custom((value, helpers) => {
+        const memoryLimit = helpers.state.ancestors?.[0]?.memoryLimit;
+        if (value > 0 && !memoryLimit)
+            return helpers.message({ custom: '"memorySwap" needs "memoryLimit"' });
+        if (value > 0 && value < memoryLimit)
+            return helpers.message({ custom: '"memorySwap" (the memory and the swap) must be at least "memoryLimit"' });
+        return value;
+    }, 'Swap Limit Validation')),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "memorySwap", void 0);
+__decorate([
+    Expect(DTO.Number().positive().optional()),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "cpus", void 0);
+__decorate([
+    Expect(DTO.Number().integer().positive().optional()),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "cpuShares", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Number().integer().min(0)).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "cpuSet", void 0);
+__decorate([
+    Expect(DTO.Number().integer().positive().optional()),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "pidsLimit", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerCreateOptions.prototype, "OOMKillDisable", void 0);
+__decorate([
+    Expect(DTO.Object().pattern(DTO.String(), DTO.String()).optional()),
+    __metadata("design:type", Object)
+], ContainerCreateOptions.prototype, "sysctls", void 0);
+__decorate([
+    Expect(DTO.Number().integer().positive().optional()),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "shmSize", void 0);
+__decorate([
+    Expect(DTO.String().allow('').pattern(/^(no|always|unless-stopped|on-failure(:\d+)?)$/).optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "restartPolicy", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "stopSignal", void 0);
+__decorate([
+    Expect(DTO.Object().pattern(DTO.String(), DTO.String().ip()).optional()),
+    __metadata("design:type", Object)
+], ContainerCreateOptions.prototype, "extraHosts", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String().ip()).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "dns", void 0);

package/dist/esm/containerd/options/container/ContainerExecOptions.js

@@ -0,0 +1,59 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * A command {@link ContainerdContainer.exec} runs in a running container (else it throws
+ * {@link ContainerdContainerStateException}), waiting for its exit and capturing its output in memory. Only `cmd` is
+ * required; the process gets the container's settings (environment, user, capabilities) unless changed here.
+ * Separating its standard error and giving it a standard input use FIFOs (`mkfifo` on the host). Unlike the Docker
+ * component's options, a string `cmd` is run by a shell, the process can get an environment, a user, a standard input
+ * and a timeout, and the result holds the exit code and the two outputs apart.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('db')
+ * const result = await container.exec({
+ *     cmd: ['psql', '-U', 'postgres', '-f', '-'],
+ *     stdin: 'SELECT 1;',
+ *     timeout: 30000
+ * })
+ * if (result.exitCode !== 0) console.error(result.stderr)
+ * ```
+ */
+export class ContainerExecOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Alternatives(DTO.String(), DTO.Array(DTO.String()).min(1)).required()),
+    __metadata("design:type", Object)
+], ContainerExecOptions.prototype, "cmd", void 0);
+__decorate([
+    Expect(DTO.Object().pattern(DTO.String(), DTO.String().allow('')).optional()),
+    __metadata("design:type", Object)
+], ContainerExecOptions.prototype, "env", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerExecOptions.prototype, "workingDir", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerExecOptions.prototype, "user", void 0);
+__decorate([
+    Expect(DTO.Alternatives(DTO.String().allow(''), DTO.Binary()).optional()),
+    __metadata("design:type", Object)
+], ContainerExecOptions.prototype, "stdin", void 0);
+__decorate([
+    Expect(DTO.Number().integer().positive().optional()),
+    __metadata("design:type", Number)
+], ContainerExecOptions.prototype, "timeout", void 0);

package/dist/esm/containerd/options/container/ContainerExportDirectoryOptions.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+import { Stream } from 'node:stream';
+/**
+ * What {@link ContainerdContainer.exportDirectory} archives (as tar) and where. A running container is read through
+ * its process root (its mounts included), a stopped one from its snapshot (its image layers and its changes, without
+ * its mounts). The directories, regular files and symbolic links are archived with their modes, owners and times; the
+ * devices, sockets and pipes are skipped. Both fields are required.
+ * @example
+ * ```typescript
+ * import {createWriteStream} from 'node:fs'
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * //Into a file
+ * await container.exportDirectory({path: '/etc/nginx', destination: '/tmp/nginx-config.tar'})
+ * //Into a stream
+ * await container.exportDirectory({path: '/var/log/nginx', destination: createWriteStream('/tmp/nginx-logs.tar')})
+ * ```
+ */
+export class ContainerExportDirectoryOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], ContainerExportDirectoryOptions.prototype, "path", void 0);
+__decorate([
+    Expect(DTO.Alternatives(DTO.String(), DTO.InstanceOf(Stream)).required()),
+    __metadata("design:type", Object)
+], ContainerExportDirectoryOptions.prototype, "destination", void 0);

package/dist/esm/containerd/options/container/ContainerKillOptions.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * The signal {@link ContainerdContainer.kill} sends to a running container, without waiting for it to exit. Every
+ * field is optional. A `SIGKILL` also tells containerd's restart monitor not to restart the container; the other
+ * signals do not. Unlike the Docker component's options, the signal may be a number, and all the processes can be
+ * signaled.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * //Reload nginx's configuration
+ * await container.kill({signal: 'SIGHUP'})
+ * ```
+ */
+export class ContainerKillOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Alternatives(DTO.String(), DTO.Number().integer().positive()).optional().default('SIGKILL')),
+    __metadata("design:type", Object)
+], ContainerKillOptions.prototype, "signal", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ContainerKillOptions.prototype, "all", void 0);

package/dist/esm/containerd/options/container/ContainerLogsOptions.js

@@ -0,0 +1,40 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * How {@link ContainerdContainer.logs} reads a container's logs: the file its containerd shim writes its standard
+ * output and error to, interleaved and raw (no timestamps, no stream prefix), with its previous rotated file (the
+ * component's `logMaxSize` option). Every field is optional. Unlike the Docker component's options, there is no
+ * `since`, `until` nor `timestamps`.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * //The last 100 lines, then the new ones while it runs
+ * const logs = await container.logs({tail: 100})
+ * logs.on('data', (chunk: Buffer): void => {
+ *     process.stdout.write(chunk)
+ * })
+ * ```
+ */
+export class ContainerLogsOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ContainerLogsOptions.prototype, "follow", void 0);
+__decorate([
+    Expect(DTO.Number().integer().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerLogsOptions.prototype, "tail", void 0);

package/dist/esm/containerd/options/container/ContainerRemoveOptions.js

@@ -0,0 +1,30 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * How {@link ContainerdContainer.remove} removes a container, with its snapshot, its network interfaces and its state
+ * directory (its logs); its named volumes are kept. The field is optional.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * await container.remove({force: true})
+ * ```
+ */
+export class ContainerRemoveOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ContainerRemoveOptions.prototype, "force", void 0);

package/dist/esm/containerd/options/container/ContainerResourceOptions.js

@@ -0,0 +1,63 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * The settings {@link ContainerdContainer.update} changes without creating the container again (as `docker update`
+ * does): its resource limits and its restart policy. An update giving only these fields is validated by this class and
+ * applied to the container's runtime specification and, while it runs, to its cgroup; the fields not given keep their
+ * values. A limit set to `0` (`[]` for `cpuSet`) is removed at once, from the running container too, and from the
+ * settings the container is created again with. Every field is optional. An update with any other field of
+ * {@link ContainerCreateOptions} creates the container again instead.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * //Applied to the running container
+ * await container.update({memoryLimit: 512 * 1024 * 1024, cpus: 2, restartPolicy: 'on-failure:3'})
+ * ```
+ */
+export class ContainerResourceOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Number().integer().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerResourceOptions.prototype, "memoryLimit", void 0);
+__decorate([
+    Expect(DTO.Number().integer().min(-1).optional()),
+    __metadata("design:type", Number)
+], ContainerResourceOptions.prototype, "memorySwap", void 0);
+__decorate([
+    Expect(DTO.Number().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerResourceOptions.prototype, "cpus", void 0);
+__decorate([
+    Expect(DTO.Number().integer().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerResourceOptions.prototype, "cpuShares", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Number().integer().min(0)).optional()),
+    __metadata("design:type", Array)
+], ContainerResourceOptions.prototype, "cpuSet", void 0);
+__decorate([
+    Expect(DTO.Number().integer().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerResourceOptions.prototype, "pidsLimit", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerResourceOptions.prototype, "OOMKillDisable", void 0);
+__decorate([
+    Expect(DTO.String().allow('').pattern(/^(no|always|unless-stopped|on-failure(:\d+)?)$/).optional()),
+    __metadata("design:type", String)
+], ContainerResourceOptions.prototype, "restartPolicy", void 0);

package/dist/esm/containerd/options/container/ContainerStopOptions.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * How {@link ContainerdContainer.stop} (and `restart()`) stops a container: its stop signal sent to its main process
+ * (a paused container is resumed first), then, after the timeout, `SIGKILL` sent to all its processes; its task is
+ * deleted (its exit code kept) and containerd's restart monitor told not to restart it. Every field is optional.
+ * Unlike the Docker component's options, the signal may be a number.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('db')
+ * //A minute to shut down cleanly
+ * await container.stop({signal: 'SIGINT', timeout: 60})
+ * ```
+ */
+export class ContainerStopOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Number().integer().min(0).optional().default(10)),
+    __metadata("design:type", Number)
+], ContainerStopOptions.prototype, "timeout", void 0);
+__decorate([
+    Expect(DTO.Alternatives(DTO.String(), DTO.Number().integer().positive()).optional()),
+    __metadata("design:type", Object)
+], ContainerStopOptions.prototype, "signal", void 0);

package/dist/esm/containerd/options/container/ContainerTTYConsoleSizeOptions.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * The size of a container terminal, in characters: the initial one ({@link ContainerTTYOptions.consoleSize}), or the
+ * new one given to {@link ContainerdContainerTTY.resize}. Both fields are required.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * const tty = await container.createTTY({consoleSize: {cols: 80, rows: 24}})
+ * //The user's window was resized
+ * await tty.resize({cols: 120, rows: 40})
+ * ```
+ */
+export class ContainerTTYConsoleSizeOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Number().integer().positive().required()),
+    __metadata("design:type", Number)
+], ContainerTTYConsoleSizeOptions.prototype, "cols", void 0);
+__decorate([
+    Expect(DTO.Number().integer().positive().required()),
+    __metadata("design:type", Number)
+], ContainerTTYConsoleSizeOptions.prototype, "rows", void 0);

package/dist/esm/containerd/options/container/ContainerTTYOptions.js

@@ -0,0 +1,59 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+import { ContainerTTYConsoleSizeOptions } from './ContainerTTYConsoleSizeOptions.js';
+/**
+ * The process {@link ContainerdContainer.createTTY} runs with a pseudo terminal in a running container (else it throws
+ * {@link ContainerdContainerStateException}); the terminal needs `mkfifo` on the host. Every field is optional.
+ * Unlike the Docker component's options, the environment, the working directory and the user can be set.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('web')
+ * const tty = await container.createTTY({cmd: ['/bin/bash', '-l'], consoleSize: {cols: 120, rows: 40}, user: 'www-data'})
+ * tty.onData((chunk: Buffer): void => {
+ *     process.stdout.write(chunk)
+ * })
+ * tty.write('ls -la\n')
+ * tty.write('exit\n')
+ * console.log('Exit code', await tty.wait())
+ * ```
+ */
+export class ContainerTTYOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Alternatives(DTO.String(), DTO.Array(DTO.String()).min(1)).optional()),
+    __metadata("design:type", Object)
+], ContainerTTYOptions.prototype, "cmd", void 0);
+__decorate([
+    Expect(ContainerTTYConsoleSizeOptions.optional()),
+    __metadata("design:type", ContainerTTYConsoleSizeOptions
+    /**
+     * Its environment variables, added to the container's ones (and replacing them by name); `TERM` is `xterm` unless
+     * given.
+     */
+    )
+], ContainerTTYOptions.prototype, "consoleSize", void 0);
+__decorate([
+    Expect(DTO.Object().pattern(DTO.String(), DTO.String().allow('')).optional()),
+    __metadata("design:type", Object)
+], ContainerTTYOptions.prototype, "env", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerTTYOptions.prototype, "workingDir", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerTTYOptions.prototype, "user", void 0);