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

package/dist/esm/containerd/lib/ContainerdContainerTTY.js

@@ -0,0 +1,175 @@
+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 { Provider, DTO } from '@lakutata/core';
+import { Transient, Configurable } from '@lakutata/core/decorator/di';
+import { Accept } from '@lakutata/core/decorator/dto';
+import { Duplex } from 'node:stream';
+import { ContainerTTYConsoleSizeOptions } from '../options/container/ContainerTTYConsoleSizeOptions.js';
+import { containerdError } from './ContainerdErrors.js';
+/**
+ * An interactive terminal in a running container: a process (a shell by default) run with a pseudo terminal, as
+ * `docker exec -it` does. Get it from {@link ContainerdContainer.createTTY}; do not create it yourself. Write its input
+ * with {@link ContainerdContainerTTY.write} (or {@link ContainerdContainerTTY.writable}), read its output with
+ * {@link ContainerdContainerTTY.onData} (or {@link ContainerdContainerTTY.readable}), or pipe a socket into
+ * {@link ContainerdContainerTTY.raw}. The terminal ends when its process exits or when it is closed; it is closed when
+ * the object is destroyed.
+ * @example
+ * ```typescript
+ * import {type Containerd, type ContainerdContainer, type ContainerdContainerTTY} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container: ContainerdContainer = await containerd.getContainer('worker')
+ * const tty: ContainerdContainerTTY = await container.createTTY({cmd: ['/bin/sh', '-l'], consoleSize: {cols: 120, rows: 40}})
+ * tty.onData((chunk: Buffer): void => {
+ *     process.stdout.write(chunk)
+ * })
+ * tty.write('ls -la\n')
+ * await tty.resize({cols: 100, rows: 30})
+ * tty.write('exit\n')
+ * //The exit code of the shell
+ * console.log(await tty.wait())
+ * ```
+ */
+let ContainerdContainerTTY = class ContainerdContainerTTY extends Provider {
+    #terminal;
+    #duplexStream;
+    /**
+     * Start the terminal's process in the container.
+     * @throws {ContainerdContainerStateException} The container is not running.
+     * @throws {Error} The host has no `mkfifo`; the user is not found in the container.
+     * @protected
+     */
+    async init() {
+        try {
+            this.#terminal = await this.getStore().terminal(this.getRecord(), {
+                cmd: Array.isArray(this.cmd) ? this.cmd : ['/bin/sh', '-c', this.cmd],
+                cols: this.initialConsoleSize?.cols,
+                rows: this.initialConsoleSize?.rows,
+                env: this.env,
+                workingDir: this.workingDir,
+                user: this.user
+            });
+        }
+        catch (error) {
+            throw containerdError(error);
+        }
+    }
+    /**
+     * Close the terminal, as {@link ContainerdContainerTTY.close} does.
+     * @protected
+     */
+    async destroy() {
+        await this.close();
+    }
+    /**
+     * The terminal as one duplex stream: writing sends input to the process, reading gives its output (to pipe a
+     * WebSocket or a socket into it). It is created at the first access and consumes the output from then on.
+     */
+    get raw() {
+        //Created once asked: it reads the output (which onData would not have otherwise)
+        if (!this.#duplexStream) {
+            this.#duplexStream = Duplex.from({ readable: this.#terminal.output, writable: this.#terminal.input });
+            this.#duplexStream.on('error', () => undefined);
+        }
+        return this.#duplexStream;
+    }
+    /**
+     * The terminal's input: what is written is sent to the process, as typed on a keyboard (`\x03` for Ctrl+C).
+     */
+    get writable() {
+        return this.#terminal.input;
+    }
+    /**
+     * The terminal's output: what the process prints, its standard error included; it ends when the process exits.
+     */
+    get readable() {
+        return this.#terminal.output;
+    }
+    /**
+     * Resize the terminal's console; the process receives `SIGWINCH`.
+     * @param options The new size, in columns and rows (positive integers).
+     * @throws {GRPCError} The process has exited (from `@lakutata/grpc`).
+     */
+    async resize(options) {
+        await this.#terminal.resize(options.cols, options.rows);
+    }
+    /**
+     * Listen to the terminal's output. Each call adds a listener.
+     * @param handler Called with each chunk of output.
+     */
+    onData(handler) {
+        this.#terminal.output.on('data', handler);
+    }
+    /**
+     * Send input to the terminal's process.
+     * @param data The input, as text or bytes (`'ls\n'`, a newline to submit a line).
+     */
+    write(data) {
+        this.#terminal.input.write(data);
+    }
+    /**
+     * Wait for the terminal's process to exit; the terminal is then closed.
+     * @returns Its exit code (`137` when it was closed by {@link ContainerdContainerTTY.close}).
+     */
+    async wait() {
+        return await this.#terminal.exited;
+    }
+    /**
+     * Close the terminal: kill its process with `SIGKILL` and release its FIFOs. Nothing happens when it is already
+     * closed.
+     */
+    async close() {
+        await this.#terminal?.close();
+    }
+};
+__decorate([
+    Configurable(DTO.Function()),
+    __metadata("design:type", Function)
+], ContainerdContainerTTY.prototype, "getStore", void 0);
+__decorate([
+    Configurable(DTO.Function()),
+    __metadata("design:type", Function)
+], ContainerdContainerTTY.prototype, "getRecord", void 0);
+__decorate([
+    Configurable(DTO.Alternatives(DTO.String(), DTO.Array(DTO.String()).min(1))),
+    __metadata("design:type", Object)
+], ContainerdContainerTTY.prototype, "cmd", void 0);
+__decorate([
+    Configurable(ContainerTTYConsoleSizeOptions.optional()),
+    __metadata("design:type", ContainerTTYConsoleSizeOptions
+    /**
+     * The environment variables added to the container's (`TERM` is `xterm` unless given).
+     * @default none
+     */
+    )
+], ContainerdContainerTTY.prototype, "initialConsoleSize", void 0);
+__decorate([
+    Configurable(DTO.Object().optional()),
+    __metadata("design:type", Object)
+], ContainerdContainerTTY.prototype, "env", void 0);
+__decorate([
+    Configurable(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerdContainerTTY.prototype, "workingDir", void 0);
+__decorate([
+    Configurable(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerdContainerTTY.prototype, "user", void 0);
+__decorate([
+    Accept(ContainerTTYConsoleSizeOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ContainerTTYConsoleSizeOptions]),
+    __metadata("design:returntype", Promise)
+], ContainerdContainerTTY.prototype, "resize", null);
+ContainerdContainerTTY = __decorate([
+    Transient()
+], ContainerdContainerTTY);
+export { ContainerdContainerTTY };

package/dist/esm/containerd/lib/ContainerdErrors.js

@@ -0,0 +1,34 @@
+import { InvalidValueException } from '@lakutata/core';
+import { ContainerdImageNotFoundException } from '../exceptions/ContainerdImageNotFoundException.js';
+import { ContainerdPlatformException } from '../exceptions/ContainerdPlatformException.js';
+import { ContainerdContainerNameConflictException } from '../exceptions/ContainerdContainerNameConflictException.js';
+import { ContainerdContainerStateException } from '../exceptions/ContainerdContainerStateException.js';
+import { ContainerdNetworkNotFoundException } from '../exceptions/ContainerdNetworkNotFoundException.js';
+import { ContainerdPathNotFoundException } from '../exceptions/ContainerdPathNotFoundException.js';
+/**
+ * The exception of an error of the client (by its code), or the one given
+ * @param error
+ * @param fallback the exception of the operation
+ */
+export function containerdError(error, fallback) {
+    const message = error?.message ?? String(error);
+    switch (error?.code) {
+        case 'NOT_FOUND':
+            return new ContainerdImageNotFoundException(message);
+        case 'PLATFORM':
+            return new ContainerdPlatformException(message);
+        case 'CONFLICT':
+            return new ContainerdContainerNameConflictException(message);
+        case 'NETWORK_NOT_FOUND':
+            return new ContainerdNetworkNotFoundException(message);
+        case 'INVALID_VALUE':
+            return new InvalidValueException(message);
+        case 'PATH_NOT_FOUND':
+            return new ContainerdPathNotFoundException(message);
+        case 'RUNNING':
+        case 'NOT_RUNNING':
+        case 'PAUSED':
+            return new ContainerdContainerStateException(message);
+    }
+    return fallback ? new fallback(message) : error;
+}

package/dist/esm/containerd/lib/ContainerdImage.js

@@ -0,0 +1,219 @@
+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 { Provider, DTO } from '@lakutata/core';
+import { Transient, Configurable } from '@lakutata/core/decorator/di';
+import { Accept } from '@lakutata/core/decorator/dto';
+import { Time } from '@lakutata/utils/Time';
+import { formatPlatform, parsePlatform } from '../../client/Platforms.js';
+import { parseReference } from '../../client/Reference.js';
+import { ImagePushOptions } from '../options/image/ImagePushOptions.js';
+import { ImageExportOptions } from '../options/image/ImageExportOptions.js';
+import { ContainerdImagePushException } from '../exceptions/ContainerdImagePushException.js';
+import { ContainerdImageExportException } from '../exceptions/ContainerdImageExportException.js';
+import { containerdError } from './ContainerdErrors.js';
+/**
+ * An image of the {@link Containerd} component's namespace: its name, digest, platforms, size and configuration, and
+ * the operations tag, push, export and remove. Get it from {@link Containerd.getImage}, {@link Containerd.listImages},
+ * {@link Containerd.pullImage}, {@link Containerd.buildImage}, {@link Containerd.importImage} or
+ * {@link ContainerdContainer.commit}; do not create it yourself. Each call returns a new object (transient).
+ *
+ * An image may hold several platforms (an index): the object describes one of them, the first one the machine runs
+ * ({@link Containerd.supportedPlatforms}), or the first one present. Its properties are a snapshot taken when it was
+ * obtained; {@link ContainerdImage.syncImageInfo} takes a new one.
+ * @example
+ * ```typescript
+ * import {type Containerd, type ContainerdImage} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const image: ContainerdImage = await containerd.pullImage({image: 'alpine:3.20', platform: ['linux/amd64', 'linux/arm64']})
+ * //docker.io/library/alpine:3.20, its platforms, the command its containers run
+ * console.log(image.name, image.platforms, image.config.cmd)
+ * const tagged: ContainerdImage = await image.tag('registry.example.com/team/alpine:3.20')
+ * await tagged.push({auth: {username: 'deploy', password: 'secret'}})
+ * //An archive loaded by docker load and nerdctl load
+ * await image.export({destination: '/tmp/alpine.tar'})
+ * await tagged.remove()
+ * ```
+ */
+let ContainerdImage = class ContainerdImage extends Provider {
+    /**
+     * Read the image's information.
+     * @throws {ContainerdImageNotFoundException} The image does not exist.
+     * @throws {ContainerdPlatformException} The content of none of its platforms is present.
+     * @protected
+     */
+    async init() {
+        await this.syncImageInfo();
+    }
+    /**
+     * Read the image's information again from containerd into the object's properties.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     * @throws {ContainerdPlatformException} The content of none of its platforms is present.
+     */
+    async syncImageInfo() {
+        const store = this.getStore();
+        let resolved;
+        let platforms;
+        try {
+            platforms = await store.platforms(this.name);
+            const supported = this.getContainerd().supportedPlatforms();
+            const preferred = platforms.find((platform) => supported.includes(formatPlatform(platform))) ?? platforms[0];
+            resolved = await store.resolve(this.name, preferred);
+        }
+        catch (error) {
+            throw containerdError(error);
+        }
+        const image = resolved.image;
+        const config = resolved.config.config ?? {};
+        this.name = image.name;
+        this.digest = image.target.digest;
+        this.mediaType = image.target.mediaType;
+        this.labels = image.labels ?? {};
+        this.createdAt = new Time(timestampMilliseconds(image.createdAt));
+        this.updatedAt = new Time(timestampMilliseconds(image.updatedAt));
+        this.platforms = platforms.map(formatPlatform);
+        this.platform = formatPlatform(resolved.platform);
+        this.os = resolved.platform.os;
+        this.arch = resolved.platform.architecture;
+        this.variant = resolved.platform.variant;
+        this.size = Number(resolved.manifest.config.size) + resolved.manifest.layers.reduce((size, layer) => size + Number(layer.size), 0);
+        this.config = {
+            env: Object.fromEntries((config.Env ?? []).map((entry) => [entry.split('=')[0], entry.slice(entry.indexOf('=') + 1)])),
+            cmd: config.Cmd ?? [],
+            entrypoint: config.Entrypoint ?? [],
+            workingDir: config.WorkingDir ?? '',
+            user: config.User ?? '',
+            exposedPorts: Object.keys(config.ExposedPorts ?? {}).map((key) => {
+                const [port, type] = key.split('/');
+                return { port: Number(port), type: (type ?? 'tcp') };
+            }),
+            volumes: Object.keys(config.Volumes ?? {}),
+            labels: config.Labels ?? {},
+            stopSignal: config.StopSignal
+        };
+    }
+    /**
+     * Give the image another name, as `docker tag` does: a new image record with the same content. An image that has
+     * this name already is replaced. This object keeps its name.
+     * @param name The new name or reference (`registry.example.com/team/alpine:3.20`), normalized as Docker does.
+     * @returns The image under its new name.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     */
+    async tag(name) {
+        try {
+            return await this.getContainerd().getImage(await this.getStore().tag(this.name, name));
+        }
+        catch (error) {
+            throw containerdError(error);
+        }
+    }
+    /**
+     * Push the image to its registry, or to another reference. With `platform`, only the manifest of that platform is
+     * pushed under the tag. Without it, when the content of all the platforms of its index is present, all of them and
+     * the index are pushed; otherwise only the manifest of the machine's platform. The credentials are `auth`, else the
+     * component's `registryAuths`. The push is aborted when the component is destroyed.
+     * @param options The `reference` to push to (the image's name by default), the `platform`, the credentials and the
+     * progress callback.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     * @throws {ContainerdPlatformException} The platform to push (`platform`, or the machine's when only some platforms
+     * are present) is not present.
+     * @throws {ContainerdImagePushException} The registry cannot be reached or refuses the push (credentials, rights).
+     */
+    async push(options) {
+        if (!options)
+            return await this.push({});
+        const registry = this.getRegistryOptions();
+        try {
+            await this.getStore().push(this.name, {
+                reference: options.reference,
+                platform: options.platform ? parsePlatform(options.platform) : undefined,
+                registry: options.auth ? { ...registry, credentials: { ...registry.credentials, [parseReference(options.reference ?? this.name).registry]: options.auth } } : registry,
+                progress: options.progressCallback
+            });
+        }
+        catch (error) {
+            throw containerdError(error, ContainerdImagePushException);
+        }
+    }
+    /**
+     * Export the image into an archive: an OCI image layout with the `manifest.json` of `docker load`, loaded by
+     * `docker load`, `nerdctl load` and {@link Containerd.importImage}.
+     * @param options The destination: a file path (created or replaced) or a writable stream.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     * @throws {ContainerdImageExportException} The archive cannot be written.
+     */
+    async export(options) {
+        try {
+            await this.getStore().export([this.name], options.destination);
+        }
+        catch (error) {
+            throw containerdError(error, ContainerdImageExportException);
+        }
+    }
+    /**
+     * Remove the image's name. Its content and snapshots are collected by containerd once no other image and no
+     * container uses them; the containers of the image keep working.
+     * @throws {ContainerdImageNotFoundException} The image no longer exists.
+     */
+    async remove() {
+        try {
+            await this.getStore().remove(this.name);
+        }
+        catch (error) {
+            throw containerdError(error);
+        }
+    }
+};
+__decorate([
+    Configurable(DTO.Function()),
+    __metadata("design:type", Function)
+], ContainerdImage.prototype, "getStore", void 0);
+__decorate([
+    Configurable(DTO.Function()),
+    __metadata("design:type", Function)
+], ContainerdImage.prototype, "getContainerd", void 0);
+__decorate([
+    Configurable(DTO.Function()),
+    __metadata("design:type", Function)
+], ContainerdImage.prototype, "getRegistryOptions", void 0);
+__decorate([
+    Configurable(DTO.String()),
+    __metadata("design:type", String)
+], ContainerdImage.prototype, "name", void 0);
+__decorate([
+    Accept(DTO.String().required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ContainerdImage.prototype, "tag", null);
+__decorate([
+    Accept(ImagePushOptions.optional()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImagePushOptions]),
+    __metadata("design:returntype", Promise)
+], ContainerdImage.prototype, "push", null);
+__decorate([
+    Accept(ImageExportOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImageExportOptions]),
+    __metadata("design:returntype", Promise)
+], ContainerdImage.prototype, "export", null);
+ContainerdImage = __decorate([
+    Transient()
+], ContainerdImage);
+export { ContainerdImage };
+/**
+ * The milliseconds of a Timestamp
+ * @param timestamp
+ */
+function timestampMilliseconds(timestamp) {
+    return timestamp ? Number(timestamp.seconds ?? 0) * 1000 + Math.floor(Number(timestamp.nanos ?? 0) / 1e6) : Date.now();
+}

package/dist/esm/containerd/options/ContainerdPruneOptions.js

@@ -0,0 +1,47 @@
+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';
+/**
+ * What {@link Containerd.prune} removes; every field is optional. A resource whose removal fails is skipped. Unlike the
+ * Docker component's options, the volumes are kept by default, and `allImages` removes the tagged images too.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * //The stopped containers and the dangling images (the defaults), and the unused volumes with their data
+ * const removed = await containerd.prune({volumes: true})
+ * console.log(removed.containers, removed.images, removed.volumes)
+ * ```
+ */
+export class ContainerdPruneOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ContainerdPruneOptions.prototype, "containers", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ContainerdPruneOptions.prototype, "images", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ContainerdPruneOptions.prototype, "allImages", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ContainerdPruneOptions.prototype, "networks", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ContainerdPruneOptions.prototype, "volumes", void 0);

package/dist/esm/containerd/options/ContainerdRegistryAuthOptions.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';
+/**
+ * The credentials of a container registry, given to a pull, a push or a build (their `auth` option) for the registry
+ * of the reference they name. They replace, for that operation, the ones the component's `registryAuths` option gives
+ * that registry. Every field is optional; without `username` nor `identityToken`, the registry is accessed anonymously.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * await containerd.pullImage({
+ *     image: 'registry.example.com:5000/team/app:1.0',
+ *     auth: {username: 'ci', password: process.env.REGISTRY_TOKEN ?? ''}
+ * })
+ * ```
+ */
+export class ContainerdRegistryAuthOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerdRegistryAuthOptions.prototype, "username", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerdRegistryAuthOptions.prototype, "password", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerdRegistryAuthOptions.prototype, "identityToken", void 0);

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

@@ -0,0 +1,62 @@
+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.commit} saves a container's file system changes as a new image: one layer on its
+ * image, for the container's platform, with the image configuration changed as asked; the image is unpacked so it can
+ * run at once. Every field is optional. Unlike the Docker component's options, the image configuration can be changed
+ * and the commit commented, and an image committed without `repoTag` is still named.
+ * @example
+ * ```typescript
+ * import {Containerd} from 'lakutata/com/containerd'
+ *
+ * declare const containerd: Containerd
+ *
+ * const container = await containerd.getContainer('builder')
+ * const image = await container.commit({
+ *     repoTag: 'registry.example.com/app:1.1',
+ *     changes: {cmd: ['node', 'server.js'], env: {NODE_ENV: 'production'}, exposedPorts: ['3000/tcp']},
+ *     comment: 'Dependencies installed',
+ *     author: 'CI <ci@example.com>'
+ * })
+ * console.log(image.name, image.digest)
+ * ```
+ */
+export class ContainerCommitOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCommitOptions.prototype, "repoTag", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ContainerCommitOptions.prototype, "pauseBeforeCommitting", void 0);
+__decorate([
+    Expect(DTO.Object({
+        cmd: DTO.Array(DTO.String()).optional(),
+        entrypoint: DTO.Array(DTO.String()).optional(),
+        env: DTO.Object().pattern(DTO.String(), DTO.String().allow('')).optional(),
+        workingDir: DTO.String().optional(),
+        user: DTO.String().optional(),
+        labels: DTO.Object().pattern(DTO.String(), DTO.String().allow('')).optional(),
+        exposedPorts: DTO.Array(DTO.String().pattern(/^\d+(\/(tcp|udp|sctp))?$/)).optional()
+    }).optional()),
+    __metadata("design:type", Object)
+], ContainerCommitOptions.prototype, "changes", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCommitOptions.prototype, "comment", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCommitOptions.prototype, "author", void 0);