@lakutata/docker 3.0.0-beta.0

package/dist/esm/exports/Docker.js

@@ -0,0 +1,73 @@
+export * from '../docker/Docker.js';
+export * from '../docker/ConnectionOptionsBuilder.js';
+/**
+ * Lib
+ */
+export * from '../docker/lib/DockerContainer.js';
+export * from '../docker/lib/DockerContainerTTY.js';
+export * from '../docker/lib/DockerImage.js';
+export * from '../docker/lib/ParseEnvToRecord.js';
+export * from '../docker/lib/ParseRepositoryTag.js';
+/**
+ * Interfaces
+ */
+export * from '../docker/interfaces/IDockerConnectionOptions.js';
+export * from '../docker/interfaces/IDockerHttpConnectionOptions.js';
+export * from '../docker/interfaces/IDockerHttpsConnectionOptions.js';
+export * from '../docker/interfaces/IDockerKeyObject.js';
+export * from '../docker/interfaces/IDockerSocketConnectionOptions.js';
+export * from '../docker/interfaces/IDockerSSHConnectionOptions.js';
+/**
+ * Types
+ */
+export * from '../docker/types/ContainerBind.js';
+export * from '../docker/types/RepositoryTag.js';
+export * from '../docker/types/ContainerCapability.js';
+export * from '../docker/types/ContainerConfig.js';
+export * from '../docker/types/ContainerDevice.js';
+export * from '../docker/types/ContainerExecResult.js';
+export * from '../docker/types/ContainerNetwork.js';
+export * from '../docker/types/ContainerPort.js';
+export * from '../docker/types/ContainerRestartPolicy.js';
+export * from '../docker/types/ContainerState.js';
+export * from '../docker/types/ContainerStats.js';
+export * from '../docker/types/DockerOutputCallback.js';
+export * from '../docker/types/ImageConfig.js';
+export * from '../docker/types/ImageExposePort.js';
+export * from '../docker/types/NetworkInfo.js';
+/**
+ * Options
+ */
+export * from '../docker/options/DockerPruneOptions.js';
+export * from '../docker/options/auth/DockerAuthOptions.js';
+export * from '../docker/options/container/ContainerCommitOptions.js';
+export * from '../docker/options/container/ContainerCreateTTYOptions.js';
+export * from '../docker/options/container/ContainerExecOptions.js';
+export * from '../docker/options/container/ContainerKillOptions.js';
+export * from '../docker/options/container/ContainerExportDirectoryOptions.js';
+export * from '../docker/options/container/ContainerLogsOptions.js';
+export * from '../docker/options/container/ContainerRemoveOptions.js';
+export * from '../docker/options/container/ContainerSettingOptions.js';
+export * from '../docker/options/container/ContainerStopOptions.js';
+export * from '../docker/options/container/ContainerTTYConsoleSizeOptions.js';
+export * from '../docker/options/image/ImageBuildOptions.js';
+export * from '../docker/options/image/ImageExportOptions.js';
+export * from '../docker/options/image/ImageImportOptions.js';
+export * from '../docker/options/image/ImagePullOptions.js';
+export * from '../docker/options/image/ImagePushOptions.js';
+export * from '../docker/options/image/ImageRemoveOptions.js';
+export * from '../docker/options/image/ImageTagOptions.js';
+export * from '../docker/options/network/NetworkCreateOptions.js';
+/**
+ * Exceptions
+ */
+export * from '../docker/exceptions/DockerConnectionException.js';
+export * from '../docker/exceptions/DockerContainerNotFoundException.js';
+export * from '../docker/exceptions/DockerImageBuildException.js';
+export * from '../docker/exceptions/DockerImageImportException.js';
+export * from '../docker/exceptions/DockerImageNotFoundException.js';
+export * from '../docker/exceptions/DockerImagePullException.js';
+export * from '../docker/exceptions/DockerImagePushException.js';
+export * from '../docker/exceptions/DockerImageRepoTagNotFoundException.js';
+export * from '../docker/exceptions/DockerNetworkNotFoundException.js';
+export * from '../docker/exceptions/DockerRequestException.js';

package/dist/types/client/BuildContext.d.ts

@@ -0,0 +1,22 @@
+import { type Gzip } from 'node:zlib';
+export type BuildContextOptions = {
+    /**
+     * The directory of the context
+     */
+    directory: string;
+    /**
+     * The files and the directories packed (their paths relative to the directory): the directories are packed with
+     * their content
+     */
+    entries: string[];
+    /**
+     * The files packed even when .dockerignore excludes them (the Dockerfile, as the docker command does)
+     */
+    always?: string[];
+};
+/**
+ * Pack the context of a build: a gzipped tar stream; the files excluded by the .dockerignore of the directory are
+ * skipped. An error of the packing (a file which cannot be read, or changes while it is read) is an error of the stream
+ * @param options
+ */
+export declare function packBuildContext(options: BuildContextOptions): Gzip;

package/dist/types/client/BuildKitProgress.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The progress of the builds of BuildKit: the "aux" of the messages "moby.buildkit.trace" of a build is a StatusResponse
+ * of BuildKit (github.com/moby/buildkit, api/services/control/control.proto), encoded by protobuf then base64. Only the
+ * fields read are decoded, by their numbers in control.proto:
+ *
+ *   StatusResponse: 1 vertexes (Vertex), 2 statuses (VertexStatus), 3 logs (VertexLog), 4 warnings (VertexWarning)
+ *   Vertex: 1 digest, 3 name, 4 cached, 5 started (Timestamp), 6 completed (Timestamp), 7 error
+ *   VertexStatus: 1 ID, 2 vertex, 3 name, 4 current, 5 total, 8 completed (Timestamp)
+ *   VertexLog: 1 vertex, 3 stream, 4 msg
+ *   VertexWarning: 1 vertex, 2 level, 3 short
+ *   Timestamp (google.protobuf): 1 seconds, 2 nanos
+ */
+export type BuildKitVertex = {
+    digest: string;
+    name: string;
+    cached: boolean;
+    /**
+     * The start and the end of the step, in milliseconds since the epoch
+     */
+    started?: number;
+    completed?: number;
+    error?: string;
+};
+export type BuildKitVertexStatus = {
+    id: string;
+    vertex: string;
+    name: string;
+    current: number;
+    total: number;
+    completed?: number;
+};
+export type BuildKitVertexLog = {
+    vertex: string;
+    /**
+     * 1 stdout, 2 stderr
+     */
+    stream: number;
+    message: Buffer;
+};
+export type BuildKitVertexWarning = {
+    vertex: string;
+    level: number;
+    short: string;
+};
+export type BuildKitStatus = {
+    vertexes: BuildKitVertex[];
+    statuses: BuildKitVertexStatus[];
+    logs: BuildKitVertexLog[];
+    warnings: BuildKitVertexWarning[];
+};
+/**
+ * Decode the progress of a build: the "aux" of a message "moby.buildkit.trace"
+ * @param aux the base64 of a StatusResponse
+ */
+export declare function decodeBuildKitStatus(aux: string): BuildKitStatus;
+/**
+ * The lines of the progress of a build, as "docker build --progress=plain" shows them: the steps are numbered in their
+ * order ("#3 [2/2] RUN npm ci"), with their output, and whether they are cached, done ("#3 DONE 1.2s") or failed
+ */
+export declare class BuildKitProgress {
+    #private;
+    /**
+     * The number of a step, given when it is first seen
+     * @param digest
+     */
+    protected step(digest: string): {
+        number: number;
+        started: boolean;
+        ended: boolean;
+    };
+    /**
+     * The lines of a status of the build
+     * @param status
+     */
+    lines(status: BuildKitStatus): string[];
+    /**
+     * The incomplete last line of the output of a step
+     * @param digest
+     */
+    protected flush(digest: string): string[];
+}

package/dist/types/client/DockerClient.d.ts

@@ -0,0 +1,196 @@
+import type { IncomingMessage } from 'node:http';
+import type { Duplex } from 'node:stream';
+import { DockerConnection, type DockerConnectionOptions } from './DockerConnection.js';
+import { type ContainerCreateResponse } from './types/ContainerCreateResponse.js';
+import { type ContainerStopQuery } from './types/ContainerStopQuery.js';
+import { type IdResponse } from './types/IdResponse.js';
+import { type NetworkCreateResponse } from './types/NetworkCreateResponse.js';
+import { type RepositoryTag } from '../docker/types/RepositoryTag.js';
+/**
+ * The exception of a request the daemon refused: the not found exception of the resource missing (told by the daemon's
+ * message, else by the meaning of the status for the request), a DockerRequestException otherwise. The other errors
+ * (the network errors, the aborts) are given as they are
+ * @param error
+ */
+export declare function dockerException(error: unknown): unknown;
+/**
+ * The registry credentials of a request
+ */
+export type DockerRegistryAuth = {
+    username?: string;
+    password?: string;
+    serveraddress?: string;
+    email?: string;
+    identitytoken?: string;
+    registrytoken?: string;
+};
+/**
+ * The client of the Docker Engine API
+ */
+export declare class DockerClient {
+    #private;
+    readonly connection: DockerConnection;
+    constructor(options?: DockerConnectionOptions);
+    /**
+     * Whether the daemon answers
+     * @param signal
+     */
+    ping(signal?: AbortSignal): Promise<string>;
+    /**
+     * The versions of the daemon
+     */
+    version(): Promise<Record<string, any>>;
+    /**
+     * Check registry credentials (docker login)
+     * @param auth
+     */
+    checkAuth(auth: DockerRegistryAuth): Promise<Record<string, any>>;
+    /** Images **/
+    listImages(query?: Record<string, unknown>, signal?: AbortSignal): Promise<Record<string, any>[]>;
+    inspectImage(name: string, signal?: AbortSignal): Promise<Record<string, any>>;
+    /**
+     * Pull an image: the stream of the progress (docker pull)
+     * @param query fromImage, tag, platform
+     * @param auth
+     * @param signal
+     */
+    pullImage(query: Record<string, unknown>, auth?: DockerRegistryAuth, signal?: AbortSignal): Promise<IncomingMessage>;
+    /**
+     * Build an image: the stream of the progress
+     * @param context the gzipped tar archive of the context
+     * @param query dockerfile, t, platform, version...
+     * @param registryConfig the credentials of the registries, by server
+     * @param signal
+     */
+    buildImage(context: NodeJS.ReadableStream, query: Record<string, unknown>, registryConfig?: Record<string, DockerRegistryAuth>, signal?: AbortSignal): Promise<IncomingMessage>;
+    /**
+     * Load the images of a tar archive (docker load): the stream of the progress
+     * @param archive
+     * @param query quiet
+     */
+    loadImage(archive: NodeJS.ReadableStream, query?: Record<string, unknown>): Promise<IncomingMessage>;
+    /**
+     * The tar archive of an image (docker save)
+     * @param name
+     */
+    exportImage(name: string): Promise<IncomingMessage>;
+    tagImage(name: string, query: RepositoryTag): Promise<void>;
+    /**
+     * Push an image: the stream of the progress
+     * @param name
+     * @param query tag, platform
+     * @param auth
+     */
+    pushImage(name: string, query: Record<string, unknown>, auth?: DockerRegistryAuth): Promise<IncomingMessage>;
+    removeImage(name: string, query?: {
+        force?: boolean;
+        noprune?: boolean;
+    }): Promise<Record<string, any>[]>;
+    pruneImages(query?: Record<string, unknown>): Promise<Record<string, any>>;
+    /** Containers **/
+    listContainers(query?: Record<string, unknown>, signal?: AbortSignal): Promise<Record<string, any>[]>;
+    /**
+     * Create a container
+     * @param body its configuration
+     * @param query name, platform
+     */
+    createContainer(body: Record<string, unknown>, query?: {
+        name?: string;
+        platform?: string;
+    }): Promise<ContainerCreateResponse>;
+    inspectContainer(id: string, signal?: AbortSignal): Promise<Record<string, any>>;
+    /**
+     * Start a container: one already started is done (HTTP 304), as the Docker CLI does
+     * @param id
+     * @param signal
+     */
+    startContainer(id: string, signal?: AbortSignal): Promise<void>;
+    /**
+     * Stop a container: one already stopped is done (HTTP 304), as the Docker CLI does
+     * @param id
+     * @param query
+     * @param signal
+     */
+    stopContainer(id: string, query?: ContainerStopQuery, signal?: AbortSignal): Promise<void>;
+    restartContainer(id: string, query?: ContainerStopQuery, signal?: AbortSignal): Promise<void>;
+    pauseContainer(id: string): Promise<void>;
+    unpauseContainer(id: string): Promise<void>;
+    killContainer(id: string, query?: {
+        signal?: string;
+    }): Promise<void>;
+    removeContainer(id: string, query?: {
+        v?: boolean;
+        force?: boolean;
+        link?: boolean;
+    }): Promise<void>;
+    /**
+     * Rename a container
+     * @param id
+     * @param name
+     */
+    renameContainer(id: string, name: string): Promise<void>;
+    /**
+     * Update the resources and the restart policy of a container, live (docker update)
+     * @param id
+     * @param body
+     */
+    updateContainer(id: string, body: Record<string, unknown>): Promise<Record<string, any>>;
+    /**
+     * Create an image of a container (docker commit)
+     * @param id
+     * @param query repo, tag, comment, author, pause, changes
+     */
+    commitContainer(id: string, query?: Record<string, unknown>): Promise<IdResponse>;
+    /**
+     * The logs of a container: multiplexed when it has no TTY
+     * @param id
+     * @param query follow, stdout, stderr, since, until, timestamps, tail
+     */
+    containerLogs(id: string, query: Record<string, unknown>): Promise<IncomingMessage>;
+    /**
+     * The statistics of a container, once
+     * @param id
+     */
+    containerStats(id: string): Promise<Record<string, any>>;
+    /**
+     * The tar archive of a path of a container
+     * @param id
+     * @param query path
+     */
+    getArchive(id: string, query: {
+        path: string;
+    }): Promise<IncomingMessage>;
+    /**
+     * Create an execution in a container
+     * @param id
+     * @param body Cmd, AttachStdin, AttachStdout, AttachStderr, Tty, ConsoleSize...
+     */
+    createExec(id: string, body: Record<string, unknown>): Promise<IdResponse>;
+    /**
+     * Start an execution, attached: its stream, read (its output, multiplexed without TTY) and written (its input)
+     * @param execId
+     * @param body Detach, Tty
+     */
+    startExec(execId: string, body: {
+        Detach?: boolean;
+        Tty?: boolean;
+    }): Promise<Duplex>;
+    resizeExec(execId: string, query: {
+        h: number;
+        w: number;
+    }): Promise<void>;
+    inspectExec(execId: string): Promise<Record<string, any>>;
+    pruneContainers(query?: Record<string, unknown>): Promise<Record<string, any>>;
+    /** Networks **/
+    listNetworks(query?: Record<string, unknown>, signal?: AbortSignal): Promise<Record<string, any>[]>;
+    createNetwork(body: Record<string, unknown>): Promise<NetworkCreateResponse>;
+    inspectNetwork(id: string): Promise<Record<string, any>>;
+    removeNetwork(id: string): Promise<void>;
+    pruneNetworks(query?: Record<string, unknown>): Promise<Record<string, any>>;
+    /** Volumes **/
+    pruneVolumes(query?: Record<string, unknown>): Promise<Record<string, any>>;
+    /**
+     * Close the connections kept alive
+     */
+    close(): void;
+}

package/dist/types/client/DockerConnection.d.ts

@@ -0,0 +1,154 @@
+import { type Agent, type ClientRequest, type IncomingMessage, type RequestOptions } from 'node:http';
+import { Duplex } from 'node:stream';
+import { DockerRequestError } from './DockerRequestError.js';
+/**
+ * A key of a TLS connection with its passphrase
+ */
+export type DockerKeyObject = {
+    pem: string | Buffer;
+    passphrase?: string;
+};
+export type DockerConnectionOptions = {
+    /**
+     * The socket of the Docker daemon (a Unix socket, or a named pipe on Windows)
+     */
+    socketPath?: string;
+    /**
+     * The host of the Docker daemon (tcp, https, ssh)
+     */
+    host?: string;
+    port?: number | string;
+    protocol?: 'http' | 'https' | 'ssh';
+    /**
+     * The user of the SSH connection
+     */
+    username?: string;
+    password?: string;
+    /**
+     * The SSH agent socket, the one of SSH_AUTH_SOCK by default
+     */
+    sshAuthAgent?: string;
+    headers?: Record<string, string>;
+    ca?: string | string[] | Buffer | Buffer[];
+    cert?: string | string[] | Buffer | Buffer[];
+    key?: string | string[] | Buffer | Buffer[] | DockerKeyObject[];
+    /**
+     * The timeout of the requests, in milliseconds
+     */
+    timeout?: number;
+    /**
+     * The API version ("1.47", or "v1.47"), negotiated with the daemon by default
+     */
+    version?: string;
+};
+/**
+ * A request to the Engine API
+ */
+export type DockerRequest = {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD';
+    path: string;
+    /**
+     * The query parameters: the objects are JSON encoded, the arrays repeat their parameter, the undefined ones are omitted
+     */
+    query?: Record<string, unknown>;
+    /**
+     * A JSON body, or a stream sent as it is (a tar archive)
+     */
+    body?: unknown;
+    headers?: Record<string, string>;
+    /**
+     * The registry credentials of the request (X-Registry-Auth)
+     */
+    auth?: Record<string, unknown>;
+    /**
+     * The registry credentials of a build (X-Registry-Config)
+     */
+    registryConfig?: Record<string, unknown>;
+    /**
+     * The meanings of the status codes: true for a success, the reason of the failure otherwise
+     */
+    statusCodes: Record<number, true | string>;
+    signal?: AbortSignal;
+};
+/**
+ * The newest API version this client is tested with (Docker 29.8): the one negotiated when the daemon supports it, so that
+ * a newer daemon answers as the tested one. An older daemon answers with its version: the fields a version does not have
+ * are missing or null
+ */
+export declare const DOCKER_API_VERSION: string;
+/**
+ * The oldest API version this client works with
+ */
+export declare const DOCKER_MIN_API_VERSION: string;
+/**
+ * Compare two API versions
+ * @param a
+ * @param b
+ */
+export declare function compareAPIVersions(a: string, b: string): number;
+/**
+ * The connection options given by the environment (DOCKER_HOST, DOCKER_TLS_VERIFY, DOCKER_CERT_PATH,
+ * DOCKER_CLIENT_TIMEOUT), else the socket of the platform: the named pipe on Windows, the socket of the user (Docker
+ * Desktop) or /var/run/docker.sock
+ */
+export declare function defaultConnectionOptions(): DockerConnectionOptions;
+/**
+ * The connection to a Docker daemon
+ */
+export declare class DockerConnection {
+    #private;
+    constructor(options?: DockerConnectionOptions);
+    /**
+     * The API version of the requests, once negotiated
+     */
+    get version(): string | undefined;
+    /**
+     * Negotiate the API version with the daemon: the newest one both support
+     */
+    negotiate(): Promise<string>;
+    /**
+     * The agent of an SSH connection: the requests are sent to "docker system dial-stdio" (ssh2, an optional dependency)
+     */
+    protected sshAgent(): Promise<Agent>;
+    /**
+     * The options of a request
+     * @param request
+     * @param streamingBody
+     */
+    protected requestOptions(request: DockerRequest, streamingBody: boolean): Promise<RequestOptions>;
+    /**
+     * Send a request: the response, once its status is known
+     * @param request
+     * @param hijack upgrade the connection to a raw stream (the TTYs, the attached executions)
+     */
+    protected send(request: DockerRequest, hijack?: boolean): Promise<{
+        response?: IncomingMessage;
+        socket?: Duplex;
+        request: ClientRequest;
+    }>;
+    /**
+     * The error of a failed response
+     * @param request
+     * @param response
+     */
+    protected failure(request: DockerRequest, response: IncomingMessage): Promise<DockerRequestError>;
+    /**
+     * A request whose response is JSON (or nothing)
+     * @param request
+     */
+    request<T = any>(request: DockerRequest): Promise<T>;
+    /**
+     * A request whose response is a stream (the progress of a pull, the logs, an archive)
+     * @param request
+     */
+    stream(request: DockerRequest): Promise<IncomingMessage>;
+    /**
+     * A request upgraded to a raw stream, read and written (the TTYs, the attached executions)
+     * @param request
+     */
+    hijack(request: DockerRequest): Promise<Duplex>;
+    /**
+     * Close the kept alive connections
+     */
+    close(): void;
+}

package/dist/types/client/DockerIgnore.d.ts

@@ -0,0 +1,44 @@
+type DockerIgnoreRule = {
+    pattern: string;
+    directories: string[];
+    negative: boolean;
+    expression?: RegExp;
+};
+/**
+ * The rules of a .dockerignore file: the files of a build context they exclude
+ */
+export declare class DockerIgnore {
+    #private;
+    protected readonly ignoreCase: boolean;
+    /**
+     * @param content the content of a .dockerignore file
+     * @param ignoreCase match the case-insensitively, as Docker does not (false by default)
+     */
+    constructor(content?: string, ignoreCase?: boolean);
+    /**
+     * Add the rules of a content
+     * @param content
+     */
+    add(content: string): this;
+    /**
+     * A rule of a line (moby/moby builder/dockerignore/dockerignore.go and pkg/fileutils/fileutils.go)
+     * @param line
+     */
+    protected rule(line: string): DockerIgnoreRule | undefined;
+    /**
+     * The regular expression of a rule (fileutils.go regexpMatch)
+     * @param rule
+     */
+    protected expression(rule: DockerIgnoreRule): RegExp;
+    /**
+     * Whether a file of the context is excluded by the rules (its path relative to the context, "/" separated)
+     * @param file
+     */
+    ignores(file: string): boolean;
+    /**
+     * Whether a file is excluded: the last rule matching it or one of its parent directories decides
+     * @param file
+     */
+    protected test(file: string): boolean;
+}
+export {};

package/dist/types/client/DockerRequestError.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A request to the Docker Engine API which failed: its message is the one of docker-modem, "(HTTP code 404) no such
+ * container - No such container: x", the status and the body of the response are given
+ */
+export declare class DockerRequestError extends Error {
+    readonly statusCode: number;
+    readonly reason: string;
+    readonly detail: string;
+    readonly json?: unknown | undefined;
+    /**
+     * @param statusCode the status of the response
+     * @param reason the meaning of the status for the request
+     * @param detail the message of the daemon
+     * @param json the body of the response
+     */
+    constructor(statusCode: number, reason: string, detail: string, json?: unknown | undefined);
+}

package/dist/types/client/DockerStreams.d.ts

@@ -0,0 +1,35 @@
+import { Transform, type TransformCallback } from 'node:stream';
+/**
+ * The stream of a frame of a multiplexed output
+ */
+export declare enum DockerStreamType {
+    STDIN = 0,
+    STDOUT = 1,
+    STDERR = 2
+}
+/**
+ * The output of a container without TTY is multiplexed: each frame is a header of 8 bytes (the stream, 3 zeros, the
+ * size as a big endian uint32) and its content. The decoder gives the contents, in their order; its "frame" event
+ * gives each content with its stream
+ */
+export declare class DockerStreamDecoder extends Transform {
+    #private;
+    _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+}
+/**
+ * The output of a multiplexed stream (or buffer), and its outputs by stream
+ * @param input
+ */
+export declare function readMultiplexed(input: NodeJS.ReadableStream | Buffer): Promise<{
+    output: string;
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Read the JSON lines of a progress (a pull, a push, a build, a load): each object is given to the callback, all of them
+ * are given back once the stream ends. The lines which are not JSON are skipped
+ * @param input
+ * @param onProgress
+ */
+export declare function followProgress<T = Record<string, any>>(input: NodeJS.ReadableStream, onProgress?: (progress: T) => void): Promise<T[]>;

package/dist/types/client/types/ContainerCreateResponse.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The response of the Docker Engine API to the creation of a container (ContainerCreateResponse)
+ */
+export type ContainerCreateResponse = {
+    Id: string;
+    Warnings?: string[];
+};

package/dist/types/client/types/ContainerStopQuery.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The query of stopping or restarting a container in the Docker Engine API
+ */
+export type ContainerStopQuery = {
+    /**
+     * The number of seconds to wait before killing the container
+     */
+    t?: number;
+    /**
+     * The signal to send to the container
+     */
+    signal?: string;
+};

package/dist/types/client/types/DeviceMapping.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A device of the host mapped into a container in the Docker Engine API (DeviceMapping)
+ */
+export type DeviceMapping = {
+    PathOnHost: string;
+    PathInContainer: string;
+    CgroupPermissions: string;
+};

package/dist/types/client/types/IdResponse.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The response of the Docker Engine API giving the id of an object it created (IdResponse)
+ */
+export type IdResponse = {
+    Id: string;
+};

package/dist/types/client/types/NetworkCreateResponse.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The response of the Docker Engine API to the creation of a network (NetworkCreateResponse)
+ */
+export type NetworkCreateResponse = {
+    Id: string;
+    Warning?: string;
+};