@lakutata/docker 3.0.0-beta.0

package/dist/esm/docker/options/auth/DockerAuthOptions.js

@@ -0,0 +1,55 @@
+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 an image registry: checked by {@link Docker.loginRepository} and
+ * {@link Docker.checkRepositoryAuth}, and sent with the image pulls ({@link ImagePullOptions.auth}), pushes
+ * ({@link ImagePushOptions.auth}) and builds ({@link ImageBuildOptions.auth}), each of them given every field set
+ * (the tokens included). Only `serverAddress` is required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const valid: boolean = await docker.checkRepositoryAuth({
+ *     serverAddress: 'registry.example.com:5000',
+ *     username: 'ci',
+ *     password: process.env.REGISTRY_PASSWORD ?? ''
+ * })
+ * ```
+ */
+export class DockerAuthOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], DockerAuthOptions.prototype, "username", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], DockerAuthOptions.prototype, "password", void 0);
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], DockerAuthOptions.prototype, "serverAddress", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", Object)
+], DockerAuthOptions.prototype, "email", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", Object)
+], DockerAuthOptions.prototype, "identityToken", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", Object)
+], DockerAuthOptions.prototype, "registryToken", void 0);

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

@@ -0,0 +1,35 @@
+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 `DockerContainer.commit()` creates an image of the container's current file system (`docker commit`), the
+ * created image returned.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const container = await docker.getContainer('web')
+ * const image = await container.commit({repoTag: 'web-snapshot:2026-10-04'})
+ * console.log(image.id)
+ * ```
+ */
+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);

package/dist/esm/docker/options/container/ContainerCreateTTYOptions.js

@@ -0,0 +1,39 @@
+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 interactive command `DockerContainer.createTTY()` runs in a running container with a terminal (`docker exec -it`),
+ * read and written through the returned `DockerContainerTTY`.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const container = await docker.getContainer('web')
+ * const tty = await container.createTTY({cmd: ['/bin/bash', '-l'], consoleSize: {cols: 120, rows: 40}})
+ * tty.onData((chunk: Buffer): void => {
+ *     process.stdout.write(chunk)
+ * })
+ * tty.write('ls -la\n')
+ * ```
+ */
+export class ContainerCreateTTYOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Alternatives(DTO.String(), DTO.Array(DTO.String()).min(1)).optional()),
+    __metadata("design:type", Object)
+], ContainerCreateTTYOptions.prototype, "cmd", void 0);
+__decorate([
+    Expect(ContainerTTYConsoleSizeOptions.optional()),
+    __metadata("design:type", ContainerTTYConsoleSizeOptions)
+], ContainerCreateTTYOptions.prototype, "consoleSize", void 0);

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

@@ -0,0 +1,34 @@
+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 command `DockerContainer.exec()` runs in a running container, without a terminal nor an input (`docker exec`); it
+ * resolves once the command exits, with its exit code and its standard output and error output apart.
+ * @example
+ * ```typescript
+ * import {Docker, type ContainerExecResult} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const container = await docker.getContainer('web')
+ * const listing: ContainerExecResult = await container.exec({cmd: ['ls', '-la', '/app']})
+ * //A command line, run by /bin/sh -c
+ * const count: ContainerExecResult = await container.exec({cmd: 'ls /app | wc -l'})
+ * if (count.exitCode !== 0) console.error(count.stderr)
+ * console.log(listing.stdout, count.stdout)
+ * ```
+ */
+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);

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

@@ -0,0 +1,35 @@
+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 `DockerContainer.exportDirectory()` copies out of a container (`docker cp`): a file or directory of the
+ * container, written as an uncompressed tar archive to a file or a stream. The container may be stopped.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const container = await docker.getContainer('web')
+ * await container.exportDirectory({path: '/var/log/nginx', destination: '/backup/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/docker/options/container/ContainerKillOptions.js

@@ -0,0 +1,32 @@
+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 `DockerContainer.kill()` kills a running container (`docker kill`).
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const container = await docker.getContainer('web')
+ * //Reload the configuration of the main process
+ * await container.kill({signal: 'SIGHUP'})
+ * //SIGKILL
+ * await container.kill()
+ * ```
+ */
+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);

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

@@ -0,0 +1,52 @@
+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';
+/**
+ * Which logs `DockerContainer.logs()` reads (`docker logs`): a readable stream of the container's standard output and
+ * error output, interleaved, as text (the multiplexing of a container without a terminal removed).
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const container = await docker.getContainer('web')
+ * //The last 100 lines of the past hour, then the new ones as they are written
+ * const logs: NodeJS.ReadableStream = await container.logs({
+ *     since: Math.floor(Date.now() / 1000) - 3600,
+ *     tail: 100,
+ *     timestamps: true
+ * })
+ * logs.pipe(process.stdout)
+ * ```
+ */
+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().optional().default(0)),
+    __metadata("design:type", Number)
+], ContainerLogsOptions.prototype, "since", void 0);
+__decorate([
+    Expect(DTO.Number().integer().optional().default(0)),
+    __metadata("design:type", Number)
+], ContainerLogsOptions.prototype, "until", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ContainerLogsOptions.prototype, "timestamps", void 0);
+__decorate([
+    Expect(DTO.Number().integer().optional()),
+    __metadata("design:type", Number)
+], ContainerLogsOptions.prototype, "tail", void 0);

package/dist/esm/docker/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 `DockerContainer.remove()` removes a container (`docker rm -v`): its anonymous volumes are removed with it, the
+ * named volumes are kept.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const container = await docker.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/docker/options/container/ContainerSettingOptions.js

@@ -0,0 +1,132 @@
+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 { ContainerCapability } from '../../types/ContainerCapability.js';
+/**
+ * The settings of a container: given to {@link Docker.createContainer} and `DockerImage.run()` (create, then start),
+ * which use the image's defaults (command, environment…) for the settings absent, and to `DockerContainer.update()`,
+ * which changes the settings given and keeps the others: the limits and the restart policy live, the others by
+ * recreating the container. Every option is optional.
+ * @example
+ * ```typescript
+ * import {Docker, ContainerCapability} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.pullImage({repo: 'nginx', tag: '1.27'})
+ * const container = await image.run({
+ *     name: 'web',
+ *     env: {TZ: 'UTC'},
+ *     memoryLimit: 256 * 1024 * 1024,
+ *     restartPolicy: 'unless-stopped',
+ *     ports: [{port: 80, type: 'tcp', hostPorts: [8080]}],
+ *     binds: [{hostPath: '/srv/web/html', containerPath: '/usr/share/nginx/html', rw: false}],
+ *     networks: [{networkName: 'front'}],
+ *     capabilities: [ContainerCapability.NET_ADMIN]
+ * })
+ * //The same container, with 512 MiB of memory, restarted 3 times at most when it fails
+ * await container.update({memoryLimit: 512 * 1024 * 1024, restartPolicy: 'on-failure:3'})
+ * ```
+ */
+export class ContainerSettingOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerSettingOptions.prototype, "name", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerSettingOptions.prototype, "hostname", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerSettingOptions.prototype, "privileged", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerSettingOptions.prototype, "tty", void 0);
+__decorate([
+    Expect(DTO.Object().optional()),
+    __metadata("design:type", Object)
+], ContainerSettingOptions.prototype, "env", void 0);
+__decorate([
+    Expect(DTO.Number().optional()),
+    __metadata("design:type", Number)
+], ContainerSettingOptions.prototype, "memoryLimit", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Number().integer()).optional()),
+    __metadata("design:type", Array)
+], ContainerSettingOptions.prototype, "cpuSet", void 0);
+__decorate([
+    Expect(DTO.Alternatives(DTO.String().allow('').valid('', 'no', 'always', 'unless-stopped', 'on-failure'), DTO.String().pattern(/^on-failure:\d+$/)).optional()),
+    __metadata("design:type", String)
+], ContainerSettingOptions.prototype, "restartPolicy", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Object({
+        port: DTO.Number().port().required(),
+        type: DTO.String().valid('tcp', 'udp').required(),
+        hostPorts: DTO.Array(DTO.Number().port()).optional().default([])
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerSettingOptions.prototype, "ports", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Object({
+        hostPath: DTO.String().required(),
+        containerPath: DTO.String().required(),
+        rw: DTO.Boolean().required()
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerSettingOptions.prototype, "binds", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Object({
+        hostPath: DTO.String().required(),
+        containerPath: DTO.String().required(),
+        cgroupPermissions: DTO.String().optional().default('rwm')
+    })).optional()),
+    __metadata("design:type", Array)
+], ContainerSettingOptions.prototype, "devices", 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)
+], ContainerSettingOptions.prototype, "networks", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ContainerSettingOptions.prototype, "OOMKillDisable", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String().valid(...Object.values(ContainerCapability))).optional()),
+    __metadata("design:type", Array)
+], ContainerSettingOptions.prototype, "capabilities", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerSettingOptions.prototype, "cgroup", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerSettingOptions.prototype, "cgroupParent", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerSettingOptions.prototype, "pidMode", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional()),
+    __metadata("design:type", Array)
+], ContainerSettingOptions.prototype, "cmd", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional()),
+    __metadata("design:type", Array)
+], ContainerSettingOptions.prototype, "entrypoint", void 0);

package/dist/esm/docker/options/container/ContainerStopOptions.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';
+/**
+ * How `DockerContainer.stop()` and `DockerContainer.restart()` stop a running container (`docker stop`): Docker sends
+ * the stop signal to its main process, then kills it with `SIGKILL` when it has not exited after the timeout.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const container = await docker.getContainer('web')
+ * //Up to 30 seconds to finish the requests in progress
+ * await container.stop({signal: 'SIGINT', timeout: 30})
+ * await container.restart({timeout: 5})
+ * ```
+ */
+export class ContainerStopOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerStopOptions.prototype, "signal", void 0);
+__decorate([
+    Expect(DTO.Number().optional()),
+    __metadata("design:type", Number)
+], ContainerStopOptions.prototype, "timeout", void 0);

package/dist/esm/docker/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: its initial size ({@link ContainerCreateTTYOptions.consoleSize}),
+ * and its new size given to `DockerContainerTTY.resize()` when the user's terminal is resized. Both are required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const container = await docker.getContainer('web')
+ * const tty = await container.createTTY({cmd: 'sh', consoleSize: {cols: 120, rows: 40}})
+ * //The user's terminal was resized
+ * await tty.resize({cols: 160, rows: 50})
+ * ```
+ */
+export class ContainerTTYConsoleSizeOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Number().required()),
+    __metadata("design:type", Number)
+], ContainerTTYConsoleSizeOptions.prototype, "cols", void 0);
+__decorate([
+    Expect(DTO.Number().required()),
+    __metadata("design:type", Number)
+], ContainerTTYConsoleSizeOptions.prototype, "rows", void 0);

package/dist/esm/docker/options/image/ImageBuildOptions.js

@@ -0,0 +1,107 @@
+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 { DockerAuthOptions } from '../auth/DockerAuthOptions.js';
+/**
+ * How {@link Docker.buildImage} builds an image with BuildKit (`docker build`), the built image returned. The build
+ * context is the listed files and directories of the working directory, without the ones its `.dockerignore` excludes;
+ * the Dockerfile is always sent. `workdir` and `files` are required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.buildImage({
+ *     workdir: '/srv/projects/api',
+ *     files: ['package.json', 'package-lock.json', 'dist'],
+ *     repoTag: 'api:1.4.0',
+ *     platform: 'linux/amd64',
+ *     buildargs: {NODE_VERSION: '22'},
+ *     outputCallback: (output: Record<string, any>): void => {
+ *         if (output.stream) console.log(output.stream)
+ *     }
+ * })
+ * console.log(image.id)
+ * ```
+ */
+export class ImageBuildOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.String().required()),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "workdir", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String()).required()),
+    __metadata("design:type", Array)
+], ImageBuildOptions.prototype, "files", void 0);
+__decorate([
+    Expect(DTO.String().optional().default('Dockerfile')),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "dockerfile", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "repoTag", void 0);
+__decorate([
+    Expect(DTO.String().allow('').optional().default('')),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "platform", void 0);
+__decorate([
+    Expect(DTO.String().allow('').optional().default('')),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "target", void 0);
+__decorate([
+    Expect(DTO.String().optional()),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "remote", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "quiet", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "quite", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "nocache", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "rm", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "forcerm", void 0);
+__decorate([
+    Expect(DTO.Number().optional()),
+    __metadata("design:type", Number)
+], ImageBuildOptions.prototype, "shmsize", void 0);
+__decorate([
+    Expect(DTO.Object().pattern(DTO.String(), DTO.String()).optional()),
+    __metadata("design:type", Object)
+], ImageBuildOptions.prototype, "buildargs", void 0);
+__decorate([
+    Expect(DockerAuthOptions.optional()),
+    __metadata("design:type", DockerAuthOptions
+    /**
+     * Receive the build progress as it arrives: the BuildKit progress as the lines of `docker build --progress=plain`
+     * (`{id: 'moby.buildkit.trace', stream: '#2 [1/2] FROM alpine'}`), and the other messages of Docker as they are
+     * sent (the built image's ID, `{aux: {ID: 'sha256:…'}}`, the errors, `{error: '…'}`).
+     */
+    )
+], ImageBuildOptions.prototype, "auth", void 0);
+__decorate([
+    Expect(DTO.Function().optional()),
+    __metadata("design:type", Function)
+], ImageBuildOptions.prototype, "outputCallback", void 0);