@lakutata/docker 3.0.0-beta.0

package/dist/cjs/docker/options/DockerPruneOptions.js

@@ -0,0 +1,47 @@
+"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.DockerPruneOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * Which unused resources {@link Docker.prune} removes, each kind as its `docker … prune` command does without options.
+ * Called without options, it prunes the containers and the images; the networks and the volumes only when asked (the
+ * volumes, as `docker system prune --volumes`).
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * //The stopped containers and the unused networks, keeping the images and the volumes
+ * await docker.prune({containers: true, images: false, networks: true, volumes: false})
+ * ```
+ */
+class DockerPruneOptions extends core_1.DTO {
+}
+exports.DockerPruneOptions = DockerPruneOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], DockerPruneOptions.prototype, "containers", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], DockerPruneOptions.prototype, "images", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], DockerPruneOptions.prototype, "networks", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], DockerPruneOptions.prototype, "volumes", void 0);

package/dist/cjs/docker/options/auth/DockerAuthOptions.d.ts

@@ -0,0 +1,46 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class DockerAuthOptions extends DTO {
+    /**
+     * The user name.
+     */
+    username?: string;
+    /**
+     * The password, or a personal access token of the registry.
+     */
+    password?: string;
+    /**
+     * The registry address, a host name or an IP address with its port when it is not the default one, without a
+     * protocol (`registry.example.com`, `10.0.0.5:5000`). Required.
+     */
+    serverAddress: string;
+    /**
+     * The e-mail address of the account, for the old registries asking for it; the current ones ignore it.
+     */
+    email?: string | undefined;
+    /**
+     * An identity token (an OAuth refresh token) the registry gave at a previous login, used instead of the password.
+     */
+    identityToken?: string | undefined;
+    /**
+     * A bearer token the registry gave, used instead of the user name and the password.
+     */
+    registryToken?: string | undefined;
+}

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

@@ -0,0 +1,59 @@
+"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.DockerAuthOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@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 ?? ''
+ * })
+ * ```
+ */
+class DockerAuthOptions extends core_1.DTO {
+}
+exports.DockerAuthOptions = DockerAuthOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], DockerAuthOptions.prototype, "username", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], DockerAuthOptions.prototype, "password", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], DockerAuthOptions.prototype, "serverAddress", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", Object)
+], DockerAuthOptions.prototype, "email", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", Object)
+], DockerAuthOptions.prototype, "identityToken", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", Object)
+], DockerAuthOptions.prototype, "registryToken", void 0);

package/dist/cjs/docker/options/container/ContainerCommitOptions.d.ts

@@ -0,0 +1,28 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class ContainerCommitOptions extends DTO {
+    /**
+     * The repository and tag of the image, `repo:tag` (`my-app:snapshot`, `registry.example.com:5000/team/app:1.0`); a
+     * repository without a tag is tagged `latest`. Without it, the image has no name (dangling) and is known by its ID
+     * only.
+     */
+    repoTag?: string;
+    /**
+     * Pause the container while the image is created, for a consistent file system; it resumes after.
+     * @default true
+     */
+    pauseBeforeCommitting?: boolean;
+}

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

@@ -0,0 +1,39 @@
+"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.ContainerCommitOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@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)
+ * ```
+ */
+class ContainerCommitOptions extends core_1.DTO {
+}
+exports.ContainerCommitOptions = ContainerCommitOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ContainerCommitOptions.prototype, "repoTag", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ContainerCommitOptions.prototype, "pauseBeforeCommitting", void 0);

package/dist/cjs/docker/options/container/ContainerCreateTTYOptions.d.ts

@@ -0,0 +1,32 @@
+import { DTO } from '@lakutata/core';
+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 declare class ContainerCreateTTYOptions extends DTO {
+    /**
+     * The command: the executable followed by its arguments (`['/bin/bash', '-l']`, at least one item), run as they
+     * are; or a command line (`'top -d 1'`), run by `/bin/sh -c`. The default needs a shell in the image (not in the
+     * distroless ones).
+     * @default ['/bin/sh']
+     */
+    cmd?: string | string[];
+    /**
+     * The terminal's initial size; without it, Docker's default size, until `DockerContainerTTY.resize()` is called.
+     */
+    consoleSize?: ContainerTTYConsoleSizeOptions;
+}

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

@@ -0,0 +1,43 @@
+"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.ContainerCreateTTYOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const ContainerTTYConsoleSizeOptions_js_1 = require("./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')
+ * ```
+ */
+class ContainerCreateTTYOptions extends core_1.DTO {
+}
+exports.ContainerCreateTTYOptions = ContainerCreateTTYOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Alternatives(core_1.DTO.String(), core_1.DTO.Array(core_1.DTO.String()).min(1)).optional()),
+    __metadata("design:type", Object)
+], ContainerCreateTTYOptions.prototype, "cmd", void 0);
+__decorate([
+    (0, dto_1.Expect)(ContainerTTYConsoleSizeOptions_js_1.ContainerTTYConsoleSizeOptions.optional()),
+    __metadata("design:type", ContainerTTYConsoleSizeOptions_js_1.ContainerTTYConsoleSizeOptions)
+], ContainerCreateTTYOptions.prototype, "consoleSize", void 0);

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

@@ -0,0 +1,26 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class ContainerExecOptions extends DTO {
+    /**
+     * The command: the executable followed by its arguments (`['ls', '-la', '/app']`, at least one item), run as they
+     * are; or a command line (`'ls /app | wc -l'`), run by `/bin/sh -c`, which needs a shell in the container.
+     * Required.
+     */
+    cmd: string | string[];
+}

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

@@ -0,0 +1,38 @@
+"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");
+/**
+ * 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)
+ * ```
+ */
+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);

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

@@ -0,0 +1,27 @@
+import { DTO } from '@lakutata/core';
+import { Writable } 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 declare class ContainerExportDirectoryOptions extends DTO {
+    /**
+     * The absolute path of the file or directory in the container (`/var/log/nginx`); the archive holds it under its
+     * base name (`nginx/…`). Required.
+     */
+    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. Required.
+     */
+    destination: string | Writable;
+}

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

@@ -0,0 +1,39 @@
+"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 `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'})
+ * ```
+ */
+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/docker/options/container/ContainerKillOptions.d.ts

@@ -0,0 +1,25 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class ContainerKillOptions extends DTO {
+    /**
+     * The signal sent to the container's main process: a name (`'SIGHUP'`, `'SIGTERM'`, also without its `SIG` prefix)
+     * or a number (`15`, `'15'`). A signal the daemon does not know is refused by it (`DockerRequestException`,
+     * HTTP 400 or 500).
+     * @default 'SIGKILL'
+     */
+    signal?: string | number;
+}

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

@@ -0,0 +1,36 @@
+"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");
+/**
+ * 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()
+ * ```
+ */
+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);

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

@@ -0,0 +1,48 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class ContainerLogsOptions extends DTO {
+    /**
+     * Keep the stream open and give the new lines as the container writes them (`docker logs --follow`): the stream
+     * ends when the container stops. `false` ends the stream after the existing lines.
+     * @default true
+     */
+    follow?: boolean;
+    /**
+     * Only the lines written from this time on, a UNIX timestamp in seconds; `0` for no lower bound.
+     * @default 0
+     */
+    since?: number;
+    /**
+     * Only the lines written before this time, a UNIX timestamp in seconds; `0` for no upper bound.
+     * @default 0
+     */
+    until?: number;
+    /**
+     * Prefix each line with the time it was written, an RFC 3339 date with nanoseconds
+     * (`2026-10-04T08:15:30.123456789Z `).
+     * @default false
+     */
+    timestamps?: boolean;
+    /**
+     * Only this number of lines, from the end of the existing logs; all the lines when absent.
+     */
+    tail?: number;
+}

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

@@ -0,0 +1,56 @@
+"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");
+/**
+ * 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)
+ * ```
+ */
+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().optional().default(0)),
+    __metadata("design:type", Number)
+], ContainerLogsOptions.prototype, "since", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().optional().default(0)),
+    __metadata("design:type", Number)
+], ContainerLogsOptions.prototype, "until", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ContainerLogsOptions.prototype, "timestamps", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().integer().optional()),
+    __metadata("design:type", Number)
+], ContainerLogsOptions.prototype, "tail", void 0);

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

@@ -0,0 +1,22 @@
+import { DTO } from '@lakutata/core';
+/**
+ * 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 declare class ContainerRemoveOptions extends DTO {
+    /**
+     * Kill the container first when it is running (`docker rm --force`); without it, removing a running container
+     * fails.
+     * @default false
+     */
+    force?: boolean;
+}