@lakutata/docker 3.0.0-beta.0

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

@@ -0,0 +1,111 @@
+"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.ImageBuildOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const DockerAuthOptions_js_1 = require("../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)
+ * ```
+ */
+class ImageBuildOptions extends core_1.DTO {
+}
+exports.ImageBuildOptions = ImageBuildOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "workdir", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Array(core_1.DTO.String()).required()),
+    __metadata("design:type", Array)
+], ImageBuildOptions.prototype, "files", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional().default('Dockerfile')),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "dockerfile", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "repoTag", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('').optional().default('')),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "platform", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().allow('').optional().default('')),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "target", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ImageBuildOptions.prototype, "remote", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "quiet", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "quite", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "nocache", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "rm", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ImageBuildOptions.prototype, "forcerm", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Number().optional()),
+    __metadata("design:type", Number)
+], ImageBuildOptions.prototype, "shmsize", 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)
+], ImageBuildOptions.prototype, "buildargs", void 0);
+__decorate([
+    (0, dto_1.Expect)(DockerAuthOptions_js_1.DockerAuthOptions.optional()),
+    __metadata("design:type", DockerAuthOptions_js_1.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([
+    (0, dto_1.Expect)(core_1.DTO.Function().optional()),
+    __metadata("design:type", Function)
+], ImageBuildOptions.prototype, "outputCallback", void 0);

package/dist/cjs/docker/options/image/ImageExportOptions.d.ts

@@ -0,0 +1,33 @@
+import { DTO } from '@lakutata/core';
+/**
+ * How `DockerImage.export()` saves an image as a tar archive (`docker save`), which {@link Docker.importImage} or
+ * `docker load` loads back. `destination` is required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.getImage('api:1.4.0')
+ * //Loaded back as api:stable
+ * await image.export({destination: '/backup/api.tar', repoTag: 'api:stable'})
+ * ```
+ */
+export declare class ImageExportOptions extends DTO {
+    /**
+     * Where the archive is written: the path of a file, created or replaced, or a writable stream, ended once the
+     * archive is written. Required.
+     */
+    destination: string | NodeJS.WritableStream;
+    /**
+     * The `repo:tag` the archive names the image with, which the image gets back when loaded (`api:1.4.0`). Without it,
+     * the image is saved by its ID: it is loaded back without a name.
+     */
+    repoTag?: string;
+    /**
+     * Tag the image with `repoTag` first when it does not have it; `false` fails the export with
+     * `DockerImageRepoTagNotFoundException` instead.
+     * @default true
+     */
+    createRepoTagIfNotExists?: boolean;
+}

package/dist/cjs/docker/options/image/ImageExportOptions.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.ImageExportOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const node_stream_1 = require("node:stream");
+/**
+ * How `DockerImage.export()` saves an image as a tar archive (`docker save`), which {@link Docker.importImage} or
+ * `docker load` loads back. `destination` is required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.getImage('api:1.4.0')
+ * //Loaded back as api:stable
+ * await image.export({destination: '/backup/api.tar', repoTag: 'api:stable'})
+ * ```
+ */
+class ImageExportOptions extends core_1.DTO {
+}
+exports.ImageExportOptions = ImageExportOptions;
+__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)
+], ImageExportOptions.prototype, "destination", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ImageExportOptions.prototype, "repoTag", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ImageExportOptions.prototype, "createRepoTagIfNotExists", void 0);

package/dist/cjs/docker/options/image/ImageImportOptions.d.ts

@@ -0,0 +1,28 @@
+import { DTO } from '@lakutata/core';
+/**
+ * How {@link Docker.importImage} loads an image from a tar archive made by `DockerImage.export()` or `docker save`
+ * (`docker load`), the loaded image returned. `source` is required.
+ * @example
+ * ```typescript
+ * import {createReadStream} from 'node:fs'
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.importImage({source: '/backup/api.tar'})
+ * //Or from a stream: an upload, a download
+ * const copy = await docker.importImage({source: createReadStream('/backup/api.tar')})
+ * console.log(image.repoTags, copy.id)
+ * ```
+ */
+export declare class ImageImportOptions extends DTO {
+    /**
+     * The archive: the path of a file, or a readable stream of it. Required.
+     */
+    source: string | NodeJS.ReadableStream;
+    /**
+     * Have Docker report no progress while it loads the archive (`docker load --quiet`).
+     * @default false
+     */
+    quiet?: boolean;
+}

package/dist/cjs/docker/options/image/ImageImportOptions.js

@@ -0,0 +1,42 @@
+"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.ImageImportOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const node_stream_1 = require("node:stream");
+/**
+ * How {@link Docker.importImage} loads an image from a tar archive made by `DockerImage.export()` or `docker save`
+ * (`docker load`), the loaded image returned. `source` is required.
+ * @example
+ * ```typescript
+ * import {createReadStream} from 'node:fs'
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.importImage({source: '/backup/api.tar'})
+ * //Or from a stream: an upload, a download
+ * const copy = await docker.importImage({source: createReadStream('/backup/api.tar')})
+ * console.log(image.repoTags, copy.id)
+ * ```
+ */
+class ImageImportOptions extends core_1.DTO {
+}
+exports.ImageImportOptions = ImageImportOptions;
+__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)
+], ImageImportOptions.prototype, "source", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ImageImportOptions.prototype, "quiet", void 0);

package/dist/cjs/docker/options/image/ImagePullOptions.d.ts

@@ -0,0 +1,49 @@
+import { DTO } from '@lakutata/core';
+import { DockerAuthOptions } from '../auth/DockerAuthOptions.js';
+import type { DockerOutputCallback } from '../../types/DockerOutputCallback.js';
+/**
+ * Which image {@link Docker.pullImage} pulls from its registry (`docker pull`), the pulled image returned. `repo` is
+ * required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const nginx = await docker.pullImage({repo: 'nginx', tag: '1.27-alpine'})
+ * const app = await docker.pullImage({
+ *     repo: 'registry.example.com:5000/team/app',
+ *     tag: '2.1.0',
+ *     platform: 'linux/arm64',
+ *     auth: {serverAddress: 'registry.example.com:5000', username: 'ci', password: process.env.REGISTRY_PASSWORD ?? ''},
+ *     outputCallback: (output: Record<string, any>): void => console.log(output.status, output.id ?? '')
+ * })
+ * console.log(nginx.id, app.id)
+ * ```
+ */
+export declare class ImagePullOptions extends DTO {
+    /**
+     * The repository, with its registry when it is not Docker Hub (`nginx`, `bitnami/redis`,
+     * `registry.example.com:5000/team/app`), without the tag. Required.
+     */
+    repo: string;
+    /**
+     * The tag pulled (`1.27-alpine`).
+     * @default 'latest'
+     */
+    tag?: string;
+    /**
+     * The platform pulled from a multi-platform image, `os[/arch[/variant]]` (`linux/arm64`); the Docker host's
+     * platform when absent.
+     */
+    platform?: string;
+    /**
+     * The credentials of a private registry; all of them are sent, the tokens included.
+     */
+    auth?: DockerAuthOptions;
+    /**
+     * Receive the pull progress as Docker sends it (`{status: 'Downloading', id: '<layer>', progressDetail: {current,
+     * total}}`).
+     */
+    outputCallback?: DockerOutputCallback;
+}

package/dist/cjs/docker/options/image/ImagePullOptions.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.ImagePullOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const DockerAuthOptions_js_1 = require("../auth/DockerAuthOptions.js");
+/**
+ * Which image {@link Docker.pullImage} pulls from its registry (`docker pull`), the pulled image returned. `repo` is
+ * required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const nginx = await docker.pullImage({repo: 'nginx', tag: '1.27-alpine'})
+ * const app = await docker.pullImage({
+ *     repo: 'registry.example.com:5000/team/app',
+ *     tag: '2.1.0',
+ *     platform: 'linux/arm64',
+ *     auth: {serverAddress: 'registry.example.com:5000', username: 'ci', password: process.env.REGISTRY_PASSWORD ?? ''},
+ *     outputCallback: (output: Record<string, any>): void => console.log(output.status, output.id ?? '')
+ * })
+ * console.log(nginx.id, app.id)
+ * ```
+ */
+class ImagePullOptions extends core_1.DTO {
+}
+exports.ImagePullOptions = ImagePullOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], ImagePullOptions.prototype, "repo", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional().default('latest')),
+    __metadata("design:type", String)
+], ImagePullOptions.prototype, "tag", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ImagePullOptions.prototype, "platform", void 0);
+__decorate([
+    (0, dto_1.Expect)(DockerAuthOptions_js_1.DockerAuthOptions.optional()),
+    __metadata("design:type", DockerAuthOptions_js_1.DockerAuthOptions
+    /**
+     * Receive the pull progress as Docker sends it (`{status: 'Downloading', id: '<layer>', progressDetail: {current,
+     * total}}`).
+     */
+    )
+], ImagePullOptions.prototype, "auth", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Function().optional()),
+    __metadata("design:type", Function)
+], ImagePullOptions.prototype, "outputCallback", void 0);

package/dist/cjs/docker/options/image/ImagePushOptions.d.ts

@@ -0,0 +1,41 @@
+import { DTO } from '@lakutata/core';
+import { DockerAuthOptions } from '../auth/DockerAuthOptions.js';
+import { type DockerOutputCallback } from '../../types/DockerOutputCallback.js';
+/**
+ * Where `DockerImage.push()` pushes an image (`docker push`): the image is tagged `repo:tag` first, then pushed to the
+ * registry of `repo`. `repo` is required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.getImage('api:1.4.0')
+ * await image.push({
+ *     repo: 'registry.example.com:5000/team/api',
+ *     tag: '1.4.0',
+ *     auth: {serverAddress: 'registry.example.com:5000', username: 'ci', password: process.env.REGISTRY_PASSWORD ?? ''}
+ * })
+ * ```
+ */
+export declare class ImagePushOptions extends DTO {
+    /**
+     * The repository pushed to, with its registry when it is not Docker Hub (`registry.example.com:5000/team/api`,
+     * `myuser/api`), without the tag. Required.
+     */
+    repo: string;
+    /**
+     * The tag pushed (`1.4.0`).
+     * @default 'latest'
+     */
+    tag?: string;
+    /**
+     * The credentials of the registry; all of them are sent, the tokens included.
+     */
+    auth?: DockerAuthOptions;
+    /**
+     * Receive the push progress as Docker sends it (`{status: 'Pushing', id: '<layer>', progressDetail: {current,
+     * total}}`).
+     */
+    outputCallback?: DockerOutputCallback;
+}

package/dist/cjs/docker/options/image/ImagePushOptions.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.ImagePushOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const DockerAuthOptions_js_1 = require("../auth/DockerAuthOptions.js");
+/**
+ * Where `DockerImage.push()` pushes an image (`docker push`): the image is tagged `repo:tag` first, then pushed to the
+ * registry of `repo`. `repo` is required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.getImage('api:1.4.0')
+ * await image.push({
+ *     repo: 'registry.example.com:5000/team/api',
+ *     tag: '1.4.0',
+ *     auth: {serverAddress: 'registry.example.com:5000', username: 'ci', password: process.env.REGISTRY_PASSWORD ?? ''}
+ * })
+ * ```
+ */
+class ImagePushOptions extends core_1.DTO {
+}
+exports.ImagePushOptions = ImagePushOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], ImagePushOptions.prototype, "repo", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional().default('latest')),
+    __metadata("design:type", String)
+], ImagePushOptions.prototype, "tag", void 0);
+__decorate([
+    (0, dto_1.Expect)(DockerAuthOptions_js_1.DockerAuthOptions.optional()),
+    __metadata("design:type", DockerAuthOptions_js_1.DockerAuthOptions
+    /**
+     * Receive the push progress as Docker sends it (`{status: 'Pushing', id: '<layer>', progressDetail: {current,
+     * total}}`).
+     */
+    )
+], ImagePushOptions.prototype, "auth", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Function().optional()),
+    __metadata("design:type", Function)
+], ImagePushOptions.prototype, "outputCallback", void 0);

package/dist/cjs/docker/options/image/ImageRemoveOptions.d.ts

@@ -0,0 +1,26 @@
+import { DTO } from '@lakutata/core';
+/**
+ * How `DockerImage.remove()` removes an image by its ID (`docker rmi`).
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.getImage('api:1.3.0')
+ * //Fails when a container uses the image
+ * await image.remove({force: false})
+ * ```
+ */
+export declare class ImageRemoveOptions extends DTO {
+    /**
+     * Remove the image even when it has several tags or stopped containers use it (`docker rmi --force`); `false`
+     * fails the removal in these cases. A running container's image is not removed.
+     * @default true
+     */
+    force?: boolean;
+    /**
+     * Keep the untagged parent images (`docker rmi --no-prune`); they are removed with the image when absent.
+     */
+    noprune?: boolean;
+}

package/dist/cjs/docker/options/image/ImageRemoveOptions.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.ImageRemoveOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * How `DockerImage.remove()` removes an image by its ID (`docker rmi`).
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.getImage('api:1.3.0')
+ * //Fails when a container uses the image
+ * await image.remove({force: false})
+ * ```
+ */
+class ImageRemoveOptions extends core_1.DTO {
+}
+exports.ImageRemoveOptions = ImageRemoveOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ImageRemoveOptions.prototype, "force", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ImageRemoveOptions.prototype, "noprune", void 0);

package/dist/cjs/docker/options/image/ImageTagOptions.d.ts

@@ -0,0 +1,25 @@
+import { DTO } from '@lakutata/core';
+/**
+ * The name `DockerImage.tag()` gives an image (`docker tag`), in addition to its other ones. `repo` is required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.getImage('api:1.4.0')
+ * await image.tag({repo: 'registry.example.com:5000/team/api', tag: 'stable'})
+ * console.log(image.repoTags)
+ * ```
+ */
+export declare class ImageTagOptions extends DTO {
+    /**
+     * The repository, with its registry when it is not Docker Hub (`someuser/someimage`,
+     * `registry.example.com:5000/team/api`). Required.
+     */
+    repo: string;
+    /**
+     * The tag (`stable`); Docker uses `latest` when absent.
+     */
+    tag?: string;
+}

package/dist/cjs/docker/options/image/ImageTagOptions.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.ImageTagOptions = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+/**
+ * The name `DockerImage.tag()` gives an image (`docker tag`), in addition to its other ones. `repo` is required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image = await docker.getImage('api:1.4.0')
+ * await image.tag({repo: 'registry.example.com:5000/team/api', tag: 'stable'})
+ * console.log(image.repoTags)
+ * ```
+ */
+class ImageTagOptions extends core_1.DTO {
+}
+exports.ImageTagOptions = ImageTagOptions;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], ImageTagOptions.prototype, "repo", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().optional()),
+    __metadata("design:type", String)
+], ImageTagOptions.prototype, "tag", void 0);

package/dist/cjs/docker/options/network/NetworkCreateOptions.d.ts

@@ -0,0 +1,54 @@
+import { DTO } from '@lakutata/core';
+import { NetworkIPAMConfig } from '../../types/NetworkInfo.js';
+/**
+ * The network {@link Docker.createNetwork} creates (`docker network create`), the created network returned. Only `name`
+ * is required.
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const network = await docker.createNetwork({
+ *     name: 'back',
+ *     internal: true,
+ *     NetworkIPAMConfigs: [{subnet: '172.28.0.0/16', range: '172.28.5.0/24', gateway: '172.28.0.1'}]
+ * })
+ * //Its containers get their addresses from 172.28.5.0/24, or the static ones given to their settings
+ * console.log(network.id)
+ * ```
+ */
+export declare class NetworkCreateOptions extends DTO {
+    /**
+     * The network name, unique on the Docker host. Required.
+     */
+    name: string;
+    /**
+     * The driver's options, by name (`{'com.docker.network.bridge.name': 'br-back'}` for `bridge`,
+     * `{parent: 'eth0'}` for `macvlan` and `ipvlan`).
+     * @default {}
+     */
+    options?: Record<string, string>;
+    /**
+     * The network driver: `'bridge'`, `'ipvlan'` or `'macvlan'`; another value fails the validation.
+     * @default 'bridge'
+     */
+    driver?: 'bridge' | 'ipvlan' | 'macvlan';
+    /**
+     * The network's address ranges, each one required to have its `subnet` (in CIDR notation) and its `gateway` (an
+     * address without a prefix length), its `range` optional (in CIDR notation); a value in another notation fails the
+     * validation. Empty or absent for a subnet Docker chooses. Its name is in PascalCase, unlike the other options.
+     * @default []
+     */
+    NetworkIPAMConfigs?: NetworkIPAMConfig[];
+    /**
+     * Isolate the network from the outside (`docker network create --internal`): its containers reach each other, not
+     * the host's networks nor the Internet.
+     */
+    internal?: boolean;
+    /**
+     * Enable IPv6 on the network (`docker network create --ipv6`); give it an IPv6 subnet in `NetworkIPAMConfigs`, or
+     * Docker allocates one from its default pools when configured.
+     */
+    enableIPv6?: boolean;
+}