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

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

@@ -0,0 +1,239 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerCreateOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@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()
+ * ```
+ */
+class ContainerCreateOptions extends core_1.DTO {
+}
+exports.ContainerCreateOptions = ContainerCreateOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "image", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "platform", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().pattern(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/).optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "name", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "hostname", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.String()).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "cmd", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.String()).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "entrypoint", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Object().pattern(core_1.DTO.String(), core_1.DTO.String().allow('')).optional()),
+    __metadata("design:type", Object)
+], ContainerCreateOptions.prototype, "env", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "workingDir", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "user", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Object().pattern(core_1.DTO.String(), core_1.DTO.String().allow('')).optional()),
+    __metadata("design:type", Object)
+], ContainerCreateOptions.prototype, "labels", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerCreateOptions.prototype, "privileged", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerCreateOptions.prototype, "readonlyRootfs", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.String()).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "capabilities", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.String()).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "capabilitiesDrop", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional().default('default')),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "seccompProfile", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.Object({
+        hostPath: core_1.DTO.String().required(),
+        containerPath: core_1.DTO.String().required(),
+        rw: core_1.DTO.Boolean().optional().default(true),
+        propagation: core_1.DTO.String().valid('private', 'rprivate', 'shared', 'rshared', 'slave', 'rslave').optional()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "binds", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.Object({
+        volumeName: core_1.DTO.String().pattern(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/).required(),
+        containerPath: core_1.DTO.String().required(),
+        readonly: core_1.DTO.Boolean().optional()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "volumes", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.Object({
+        containerPath: core_1.DTO.String().required(),
+        size: core_1.DTO.Number().integer().positive().optional(),
+        mode: core_1.DTO.String().pattern(/^[0-7]{3,4}$/).optional()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "tmpfs", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.Object({
+        hostPath: core_1.DTO.String().required(),
+        containerPath: core_1.DTO.String().optional(),
+        cgroupPermissions: core_1.DTO.String().pattern(/^(?!.*(.).*\1)[rwm]{1,3}$/).optional().default('rwm')
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "devices", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.String().pattern(/^[acb] (\*|\d+):(\*|\d+) (?!.*(.).*\3)[rwm]{1,3}$/)).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "deviceCgroupRules", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().valid('host', 'none').optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "network", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.Object({
+        networkName: core_1.DTO.String().required(),
+        ip: core_1.DTO.String().allow('').ip({ version: 'ipv4' }).optional(),
+        ipv6: core_1.DTO.String().allow('').ip({ version: 'ipv6' }).optional()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "networks", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.Object({
+        port: core_1.DTO.Number().port().required(),
+        type: core_1.DTO.String().valid('tcp', 'udp', 'sctp').optional().default('tcp'),
+        hostPorts: core_1.DTO.Array(core_1.DTO.Number().port()).min(1).required(),
+        hostIP: core_1.DTO.String().ip().optional()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "ports", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().valid('host').optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "pidMode", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().valid('host').optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "ipcMode", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().valid('private', 'host').optional().default('private')),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "cgroupns", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "memoryLimit", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.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([
+    (0, dto_1.Expect)(core_1.DTO.Number().positive().optional()),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "cpus", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().positive().optional()),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "cpuShares", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.Number().integer().min(0)).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "cpuSet", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().positive().optional()),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "pidsLimit", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerCreateOptions.prototype, "OOMKillDisable", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Object().pattern(core_1.DTO.String(), core_1.DTO.String()).optional()),
+    __metadata("design:type", Object)
+], ContainerCreateOptions.prototype, "sysctls", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().positive().optional()),
+    __metadata("design:type", Number)
+], ContainerCreateOptions.prototype, "shmSize", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('').pattern(/^(no|always|unless-stopped|on-failure(:\d+)?)$/).optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "restartPolicy", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCreateOptions.prototype, "stopSignal", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Object().pattern(core_1.DTO.String(), core_1.DTO.String().ip()).optional()),
+    __metadata("design:type", Object)
+], ContainerCreateOptions.prototype, "extraHosts", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.String().ip()).optional()),
+    __metadata("design:type", Array)
+], ContainerCreateOptions.prototype, "dns", void 0);

package/dist/cjs/containerd/options/container/ContainerExecOptions.d.ts

@@ -0,0 +1,53 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class ContainerExecOptions extends DTO {
+    /**
+     * The command: its arguments (`['ls', '-la', '/data']`, at least one), or a command line run by `/bin/sh -c`
+     * (`'ls -la /data | wc -l'`), which needs a shell in the container. Required.
+     */
+    cmd: string | string[];
+    /**
+     * Its environment variables, added to the container's ones (and replacing them by name).
+     */
+    env?: Record<string, string>;
+    /**
+     * Its working directory; the container's one by default.
+     */
+    workingDir?: string;
+    /**
+     * Its user: `'user'`, `'user:group'`, `'uid'` or `'uid:gid'`, the names resolved by the container's `/etc/passwd`
+     * and `/etc/group`; the container's user by default.
+     */
+    user?: string;
+    /**
+     * The data written to its standard input, which is closed after it. Without it, the process has no standard input.
+     * Needs `mkfifo` on the host.
+     */
+    stdin?: string | Buffer;
+    /**
+     * The milliseconds it may run, a positive integer: it is then killed (`SIGKILL`) and the result has its exit code
+     * (`137`) and its output so far. No limit by default.
+     */
+    timeout?: number;
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerExecOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@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)
+ * ```
+ */
+class ContainerExecOptions extends core_1.DTO {
+}
+exports.ContainerExecOptions = ContainerExecOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Alternatives(core_1.DTO.String(), core_1.DTO.Array(core_1.DTO.String()).min(1)).required()),
+    __metadata("design:type", Object)
+], ContainerExecOptions.prototype, "cmd", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Object().pattern(core_1.DTO.String(), core_1.DTO.String().allow('')).optional()),
+    __metadata("design:type", Object)
+], ContainerExecOptions.prototype, "env", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerExecOptions.prototype, "workingDir", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerExecOptions.prototype, "user", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Alternatives(core_1.DTO.String().allow(''), core_1.DTO.Binary()).optional()),
+    __metadata("design:type", Object)
+], ContainerExecOptions.prototype, "stdin", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().positive().optional()),
+    __metadata("design:type", Number)
+], ContainerExecOptions.prototype, "timeout", void 0);

package/dist/cjs/containerd/options/container/ContainerExportDirectoryOptions.d.ts

@@ -0,0 +1,32 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class ContainerExportDirectoryOptions extends DTO {
+    /**
+     * The absolute path in the container of the directory or file archived, its symbolic links resolved in the
+     * container; it is the archive's top entry, named by its base name. A missing path fails the export.
+     */
+    path: string;
+    /**
+     * Where the tar archive is written: the path of a host file (created or replaced), or a writable stream, ended
+     * once the archive is written.
+     */
+    destination: string | NodeJS.WritableStream;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerExportDirectoryOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const node_stream_1 = require("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')})
+ * ```
+ */
+class ContainerExportDirectoryOptions extends core_1.DTO {
+}
+exports.ContainerExportDirectoryOptions = ContainerExportDirectoryOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], ContainerExportDirectoryOptions.prototype, "path", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Alternatives(core_1.DTO.String(), core_1.DTO.InstanceOf(node_stream_1.Stream)).required()),
+    __metadata("design:type", Object)
+], ContainerExportDirectoryOptions.prototype, "destination", void 0);

package/dist/cjs/containerd/options/container/ContainerKillOptions.d.ts

@@ -0,0 +1,30 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class ContainerKillOptions extends DTO {
+    /**
+     * The signal: a name (`'SIGTERM'`, `'TERM'`), its number as a string (`'15'`), or a positive integer. An unknown
+     * name fails the call.
+     * @default 'SIGKILL'
+     */
+    signal?: string | number;
+    /**
+     * Send it to all the container's processes, not only to its main process.
+     * @default false
+     */
+    all?: boolean;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerKillOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@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'})
+ * ```
+ */
+class ContainerKillOptions extends core_1.DTO {
+}
+exports.ContainerKillOptions = ContainerKillOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Alternatives(core_1.DTO.String(), core_1.DTO.Number().integer().positive()).optional().default('SIGKILL')),
+    __metadata("design:type", Object)
+], ContainerKillOptions.prototype, "signal", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ContainerKillOptions.prototype, "all", void 0);

package/dist/cjs/containerd/options/container/ContainerLogsOptions.d.ts

@@ -0,0 +1,34 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class ContainerLogsOptions extends DTO {
+    /**
+     * Keep the stream open and send the new output while the container runs (polled every 250 milliseconds); it ends
+     * once the container stops without its restart monitor restarting it. Without it, the stream ends after the
+     * existing logs.
+     * @default true
+     */
+    follow?: boolean;
+    /**
+     * The number of lines read from the end of the existing logs, a non-negative integer (`0`: none of them); all of
+     * them by default.
+     */
+    tail?: number;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerLogsOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@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)
+ * })
+ * ```
+ */
+class ContainerLogsOptions extends core_1.DTO {
+}
+exports.ContainerLogsOptions = ContainerLogsOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ContainerLogsOptions.prototype, "follow", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().min(0).optional()),
+    __metadata("design:type", Number)
+], ContainerLogsOptions.prototype, "tail", void 0);

package/dist/cjs/containerd/options/container/ContainerRemoveOptions.d.ts

@@ -0,0 +1,22 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class ContainerRemoveOptions extends DTO {
+    /**
+     * Remove a running or paused container: all its processes are killed (`SIGKILL`) first, and its restart monitor
+     * told not to restart it. Without it, such a container throws {@link ContainerdContainerStateException}.
+     * @default false
+     */
+    force?: boolean;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerRemoveOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@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})
+ * ```
+ */
+class ContainerRemoveOptions extends core_1.DTO {
+}
+exports.ContainerRemoveOptions = ContainerRemoveOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ContainerRemoveOptions.prototype, "force", void 0);