@types/dockerode

Version 3.3.9
Published 13 days ago
67.5 kB
2 dependencies
MIT license

Install

npm i @types/dockerode

yarn add @types/dockerode

pnpm add @types/dockerode

Overview

TypeScript definitions for dockerode

Index

Classes

class Config

class Config {}

constructor

constructor(modem: any, id: string);

property id

id: string;

property modem

modem: any;

method inspect

inspect: {
    (options: {}, callback: Callback<ConfigInfo>): void;
    (callback: Callback<ConfigInfo>): void;
    (options?: {}): Promise<ConfigInfo>;
};

method remove

remove: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method update

update: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

class Container

class Container {}

constructor

constructor(modem: any, id: string);

property id

id: string;

property modem

modem: any;

method attach

attach: {
    (options: {}, callback: Callback<NodeJS.ReadWriteStream>): void;
    (options: {}): Promise<NodeJS.ReadWriteStream>;
};

method changes

changes: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method commit

commit: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method copy

copy: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

Deprecated since RAPI v1.20

method exec

exec: {
    (options: ExecCreateOptions, callback: Callback<Exec>): void;
    (options: ExecCreateOptions): Promise<Exec>;
};

method export

export: {
    (options: {}, callback: Callback<NodeJS.ReadableStream>): void;
    (callback: Callback<NodeJS.ReadableStream>): void;
    (options?: {}): Promise<NodeJS.ReadableStream>;
};

method getArchive

getArchive: {
    (options: {}, callback: Callback<NodeJS.ReadableStream>): void;
    (options: {}): Promise<NodeJS.ReadableStream>;
};

method infoArchive

infoArchive: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method inspect

inspect: {
    (options: {}, callback: Callback<ContainerInspectInfo>): void;
    (callback: Callback<ContainerInspectInfo>): void;
    (options?: {}): Promise<ContainerInspectInfo>;
};

method kill

kill: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method logs

logs: {
    (
        options: ContainerLogsOptions,
        callback: Callback<NodeJS.ReadableStream>
    ): void;
    (callback: Callback<NodeJS.ReadableStream>): void;
    (options?: ContainerLogsOptions): Promise<NodeJS.ReadableStream>;
};

method pause

pause: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method putArchive

putArchive: {
    (
        file: string | Buffer | NodeJS.ReadableStream,
        options: {},
        callback: Callback<NodeJS.WritableStream>
    ): void;
    (file: any, options: {}): Promise<NodeJS.ReadWriteStream>;
};

Parameter file
Filename (will read synchronously), Buffer or stream

method remove

remove: {
    (options: ContainerRemoveOptions, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method rename

rename: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method resize

resize: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method restart

restart: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method start

start: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method stats

stats: {
    (options: {}, callback: Callback<ContainerStats>): void;
    (callback: Callback<ContainerStats>): void;
    (options?: {}): Promise<ContainerStats>;
};

method stop

stop: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method top

top: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method unpause

unpause: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method update

update: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method wait

wait: {
    (options: ContainerWaitOptions, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: ContainerWaitOptions): Promise<any>;
};

class Dockerode

class Dockerode {}

constructor

constructor(options?: Dockerode.DockerOptions);

property modem

modem: DockerModem;

method buildImage

buildImage: {
    (
        file: string | NodeJS.ReadableStream | Dockerode.ImageBuildContext,
        options: Dockerode.ImageBuildOptions,
        callback: Callback<NodeJS.ReadableStream>
    ): void;
    (file: any, callback: Callback<NodeJS.ReadableStream>): void;
    (
        file: any,
        options?: Dockerode.ImageBuildOptions
    ): Promise<NodeJS.ReadableStream>;
};

method checkAuth

checkAuth: {
    (options: any, callback: Callback<any>): void;
    (options: any): Promise<any>;
};

method createConfig

createConfig: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method createContainer

createContainer: {
    (
        options: Dockerode.ContainerCreateOptions,
        callback: Callback<Dockerode.Container>
    ): void;
    (options: Dockerode.ContainerCreateOptions): Promise<Dockerode.Container>;
};

method createImage

createImage: {
    (options: {}, callback: Callback<NodeJS.ReadableStream>): void;
    (auth: any, options: {}, callback: Callback<NodeJS.ReadableStream>): void;
    (options: {}): Promise<NodeJS.ReadableStream>;
    (auth: any, options: {}): Promise<NodeJS.ReadableStream>;
};

method createNetwork

createNetwork: {
    (
        options: Dockerode.NetworkCreateOptions,
        callback: Callback<Dockerode.Network>
    ): void;
    (options: Dockerode.NetworkCreateOptions): Promise<Dockerode.Network>;
};

method createPlugin

createPlugin: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method createSecret

createSecret: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method createService

createService: {
    (
        options: Dockerode.CreateServiceOptions,
        callback: Callback<Dockerode.ServiceCreateResponse>
    ): void;
    (
        options: Dockerode.CreateServiceOptions
    ): Promise<Dockerode.ServiceCreateResponse>;
    (
        auth: Dockerode.AuthConfig,
        options: Dockerode.ServiceSpec
    ): Promise<Dockerode.ServiceCreateResponse>;
};

method createVolume

createVolume: {
    (
        options: Dockerode.VolumeCreateOptions,
        callback: Callback<Dockerode.Volume>
    ): void;
    (callback: Callback<Dockerode.Volume>): void;
    (
        options?: Dockerode.VolumeCreateOptions
    ): Promise<Dockerode.VolumeCreateResponse>;
};

method df

df: { (callback: Callback<any>): void; (): Promise<any> };

method getConfig

getConfig: (id: string) => Dockerode.Config;

method getContainer

getContainer: (id: string) => Dockerode.Container;

method getEvents

getEvents: {
    (
        options: Dockerode.GetEventsOptions,
        callback: Callback<NodeJS.ReadableStream>
    ): void;
    (callback: Callback<NodeJS.ReadableStream>): void;
    (options?: Dockerode.GetEventsOptions): Promise<NodeJS.ReadableStream>;
};

method getExec

getExec: (id: string) => Dockerode.Exec;

method getImage

getImage: (name: string) => Dockerode.Image;

method getNetwork

getNetwork: (id: string) => Dockerode.Network;

method getNode

getNode: (id: string) => Dockerode.Node;

method getPlugin

getPlugin: (name: string, remote: any) => Dockerode.Plugin;

method getSecret

getSecret: (id: string) => Dockerode.Secret;

method getService

getService: (id: string) => Dockerode.Service;

method getTask

getTask: (id: string) => Dockerode.Task;

method getVolume

getVolume: (name: string) => Dockerode.Volume;

method importImage

importImage: {
    (
        file: string | NodeJS.ReadableStream,
        options: {},
        callback: Callback<NodeJS.ReadableStream>
    ): void;
    (file: any, callback: Callback<NodeJS.ReadableStream>): void;
    (file: any, options?: {}): Promise<NodeJS.ReadableStream>;
};

method info

info: { (callback: Callback<any>): void; (): Promise<any> };

method listConfigs

listConfigs: {
    (options: {}, callback: Callback<Dockerode.ConfigInfo[]>): void;
    (callback: Callback<Dockerode.ConfigInfo[]>): void;
    (options?: {}): Promise<Dockerode.ConfigInfo[]>;
};

method listContainers

listContainers: {
    (options: {}, callback: Callback<Dockerode.ContainerInfo[]>): void;
    (callback: Callback<Dockerode.ContainerInfo[]>): void;
    (options?: {}): Promise<Dockerode.ContainerInfo[]>;
};

method listImages

listImages: {
    (
        options: Dockerode.ListImagesOptions,
        callback: Callback<Dockerode.ImageInfo[]>
    ): void;
    (callback: Callback<Dockerode.ImageInfo[]>): void;
    (options?: Dockerode.ListImagesOptions): Promise<Dockerode.ImageInfo[]>;
};

method listNetworks

listNetworks: {
    (options: {}, callback: Callback<Dockerode.NetworkInspectInfo[]>): void;
    (callback: Callback<Dockerode.NetworkInspectInfo[]>): void;
    (options?: {}): Promise<Dockerode.NetworkInspectInfo[]>;
};

method listNodes

listNodes: {
    (options: {}, callback: Callback<any[]>): void;
    (callback: Callback<any[]>): void;
    (options?: {}): Promise<any[]>;
};

method listPlugins

listPlugins: {
    (options: {}, callback: Callback<Dockerode.PluginInfo[]>): void;
    (callback: Callback<Dockerode.PluginInfo[]>): void;
    (options?: {}): Promise<Dockerode.PluginInfo[]>;
};

method listSecrets

listSecrets: {
    (options: {}, callback: Callback<Dockerode.Secret[]>): void;
    (callback: Callback<Dockerode.Secret[]>): void;
    (options?: {}): Promise<Dockerode.Secret[]>;
};

method listServices

listServices: {
    (
        options: Dockerode.ServiceListOptions,
        callback: Callback<Dockerode.Service[]>
    ): void;
    (callback: Callback<Dockerode.Service[]>): void;
    (options?: Dockerode.ServiceListOptions): Promise<Dockerode.Service[]>;
};

method listTasks

listTasks: {
    (options: {}, callback: Callback<any[]>): void;
    (callback: Callback<any[]>): void;
    (options?: {}): Promise<any[]>;
};

method listVolumes

listVolumes: {
    (
        options: {},
        callback: Callback<{
            Volumes: Dockerode.VolumeInspectInfo[];
            Warnings: string[];
        }>
    ): void;
    (
        callback: Callback<{
            Volumes: Dockerode.VolumeInspectInfo[];
            Warnings: string[];
        }>
    ): void;
    (options?: {}): Promise<{
        Volumes: Dockerode.VolumeInspectInfo[];
        Warnings: string[];
    }>;
};

method loadImage

loadImage: {
    (
        file: string | NodeJS.ReadableStream,
        options: {},
        callback: Callback<NodeJS.ReadableStream>
    ): void;
    (file: any, callback: Callback<NodeJS.ReadableStream>): void;
    (file: any, options?: {}): Promise<NodeJS.ReadableStream>;
};

method ping

ping: { (callback: Callback<any>): void; (): Promise<any> };

method pruneContainers

pruneContainers: {
    (options: {}, callback: Callback<Dockerode.PruneContainersInfo>): void;
    (callback: Callback<Dockerode.PruneContainersInfo>): void;
    (options?: {}): Promise<Dockerode.PruneContainersInfo>;
};

method pruneImages

pruneImages: {
    (options: {}, callback: Callback<Dockerode.PruneImagesInfo>): void;
    (callback: Callback<Dockerode.PruneImagesInfo>): void;
    (options?: {}): Promise<Dockerode.PruneImagesInfo>;
};

method pruneNetworks

pruneNetworks: {
    (options: {}, callback: Callback<Dockerode.PruneNetworksInfo>): void;
    (callback: Callback<Dockerode.PruneNetworksInfo>): void;
    (options?: {}): Promise<Dockerode.PruneNetworksInfo>;
};

method pruneVolumes

pruneVolumes: {
    (options: {}, callback: Callback<Dockerode.PruneVolumesInfo>): void;
    (callback: Callback<Dockerode.PruneVolumesInfo>): void;
    (options?: {}): Promise<Dockerode.PruneVolumesInfo>;
};

method pull

pull: {
    (
        repoTag: string,
        options: {},
        callback: Callback<any>,
        auth?: {}
    ): Dockerode.Image;
    (repoTag: string, options?: {}): Promise<any>;
};

method run

run: {
    (
        image: string,
        cmd: string[],
        outputStream: NodeJS.WritableStream | NodeJS.WritableStream[],
        createOptions: {},
        startOptions: {},
        callback: Callback<any>
    ): events.EventEmitter;
    (
        image: string,
        cmd: string[],
        outputStream: any,
        startOptions: {},
        callback: Callback<any>
    ): events.EventEmitter;
    (
        image: string,
        cmd: string[],
        outputStream: any,
        callback: Callback<any>
    ): events.EventEmitter;
    (
        image: string,
        cmd: string[],
        outputStream: any,
        createOptions: {},
        callback: Callback<any>
    ): events.EventEmitter;
    (
        image: string,
        cmd: string[],
        outputStream: any,
        createOptions?: {},
        startOptions?: {}
    ): Promise<any>;
};

method searchImages

searchImages: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method swarmInit

swarmInit: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method swarmInspect

swarmInspect: { (callback: Callback<any>): void; (): Promise<any> };

method swarmJoin

swarmJoin: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method swarmLeave

swarmLeave: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method swarmUpdate

swarmUpdate: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method version

version: {
    (callback: Callback<Dockerode.DockerVersion>): void;
    (): Promise<Dockerode.DockerVersion>;
};

class Exec

class Exec {}

constructor

constructor(modem: any, id: string);

property id

id: string;

property modem

modem: any;

method inspect

inspect: {
    (callback: Callback<ExecInspectInfo>): void;
    (): Promise<ExecInspectInfo>;
};

method resize

resize: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method start

start: {
    (options: ExecStartOptions, callback: Callback<stream.Duplex>): void;
    (options: ExecStartOptions): Promise<stream.Duplex>;
};

class Image

class Image {}

constructor

constructor(modem: any, name: string);

property id

id: string;

property modem

modem: any;

method distribution

distribution: {
    (
        options: ImageDistributionOptions,
        callback: Callback<ImageDistributionInfo>
    ): void;
    (callback: Callback<ImageDistributionInfo>): void;
    (options?: ImageDistributionOptions): Promise<ImageDistributionInfo>;
};

method get

get: {
    (callback: Callback<NodeJS.ReadableStream>): void;
    (): Promise<NodeJS.ReadableStream>;
};

method history

history: { (callback: Callback<any>): void; (): Promise<any> };

method inspect

inspect: {
    (callback: Callback<ImageInspectInfo>): void;
    (): Promise<ImageInspectInfo>;
};

method push

push: {
    (options: ImagePushOptions, callback: Callback<NodeJS.ReadableStream>): void;
    (callback: Callback<NodeJS.ReadableStream>): void;
    (options?: ImagePushOptions): Promise<NodeJS.ReadableStream>;
};

method remove

remove: {
    (options: ImageRemoveOptions, callback: Callback<ImageRemoveInfo>): void;
    (callback: Callback<ImageRemoveInfo>): void;
    (options?: {}): Promise<any>;
};

method tag

tag: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

class Network

class Network {}

constructor

constructor(modem: any, id: string);

property id

id: string;

property modem

modem: any;

method connect

connect: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method disconnect

disconnect: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method inspect

inspect: { (callback: Callback<any>): void; (): Promise<any> };

method remove

remove: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

class Node

class Node {}

constructor

constructor(modem: any, id: string);

property id

id: string;

property modem

modem: any;

method inspect

inspect: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method remove

remove: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method update

update: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

class Plugin

class Plugin {}

constructor

constructor(modem: any, name: string, remote?: any);

property modem

modem: any;

property name

name: string;

property remote

remote: any;

method configure

configure: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method disable

disable: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method enable

enable: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method inspect

inspect: {
    (options: {}, callback: Callback<PluginInspectInfo>): void;
    (callback: Callback<PluginInfo>): void;
    (options?: {}): Promise<PluginInfo>;
};

method privileges

privileges: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method pull

pull: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

method push

push: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method remove

remove: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method upgrade

upgrade: {
    (auth: any, options: {}, callback: Callback<any>): void;
    (auth: any, callback: Callback<any>): void;
    (auth: any, options?: {}): Promise<any>;
};

class Secret

class Secret {}

constructor

constructor(modem: any, id: string);

property id

id: string;

property modem

modem: any;

method inspect

inspect: {
    (options: {}, callback: Callback<Secret>): void;
    (callback: Callback<Secret>): void;
    (options?: {}): Promise<Secret>;
};

method remove

remove: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method update

update: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

class Service

class Service {}

constructor

constructor(modem: any, id: string);

property id

id: string;

property modem

modem: any;

method inspect

inspect: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method logs

logs: {
    (
        options: ContainerLogsOptions,
        callback: Callback<NodeJS.ReadableStream>
    ): void;
    (callback: Callback<NodeJS.ReadableStream>): void;
    (options?: ContainerLogsOptions): Promise<NodeJS.ReadableStream>;
};

method remove

remove: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

method update

update: {
    (options: {}, callback: Callback<any>): void;
    (options: {}): Promise<any>;
};

class Task

class Task {}

constructor

constructor(modem: any, id: string);

property id

id: string;

property modem

modem: any;

method inspect

inspect: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

class Volume

class Volume {}

constructor

constructor(modem: any, name: string);

property modem

modem: any;

property name

name: string;

method inspect

inspect: {
    (options: {}, callback: Callback<VolumeInspectInfo>): void;
    (callback: Callback<VolumeInspectInfo>): void;
    (options?: {}): Promise<VolumeInspectInfo>;
};

method remove

remove: {
    (options: {}, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: {}): Promise<any>;
};

Interfaces

interface Annotations

interface Annotations {}

property Labels

Labels?: { [name: string]: string } | undefined;

property Name

Name?: string | undefined;

interface Args

interface Args {}

property Description

Description: string;

property Name

Name: string;

property Settable

Settable: string[];

property Value

Value: string;

interface AuthConfig

interface AuthConfig {}

property email

email?: string | undefined;

property password

password: string;

property serveraddress

serveraddress: string;

property username

username: string;

interface BlkioStatEntry

interface BlkioStatEntry {}

property major

major: number;

property minor

minor: number;

property op

op: string;

property value

value: number;

interface BlkioStats

interface BlkioStats {}

property io_merged_recursive

io_merged_recursive: BlkioStatEntry[];

property io_queue_recursive

io_queue_recursive: BlkioStatEntry[];

property io_service_bytes_recursive

io_service_bytes_recursive: BlkioStatEntry[];

property io_service_time_recursive

io_service_time_recursive: BlkioStatEntry[];

property io_serviced_recursive

io_serviced_recursive: BlkioStatEntry[];

property io_time_recursive

io_time_recursive: BlkioStatEntry[];

property io_wait_time_recursive

io_wait_time_recursive: BlkioStatEntry[];

property sectors_recursive

sectors_recursive: BlkioStatEntry[];

interface CAConfig

interface CAConfig {}

property ExternalCAs

ExternalCAs?: ExternalCA[] | undefined;

property ForceRotate

ForceRotate?: number | undefined;

property NodeCertExpiry

NodeCertExpiry?: Duration | undefined;

property SigningCACert

SigningCACert?: string | undefined;

property SigningCAKey

SigningCAKey?: string | undefined;

interface ClusterInfo

interface ClusterInfo extends Meta {}

property DataPathPort

DataPathPort: number;

property DefaultAddrPool

DefaultAddrPool: string[];

property ID

ID: string;

property RootRotationInProgress

RootRotationInProgress: boolean;

property Spec

Spec: Spec;

property SubnetSize

SubnetSize: number;

property TLSInfo

TLSInfo: TLSInfo;

interface ConfigInfo

interface ConfigInfo {}

property CreatedAt

CreatedAt: string;

property ID

ID: string;

property Spec

Spec?: ConfigSpec | undefined;

property UpdatedAt

UpdatedAt?: string | undefined;

property Version

Version: SecretVersion;

interface ConfigSpec

interface ConfigSpec {}

property Data

Data: string;

property Labels

Labels: { [label: string]: string };

property Name

Name: string;

interface ConfigVersion

interface ConfigVersion {}

property Index

Index: number;

interface ContainerCreateOptions

interface ContainerCreateOptions {}

property abortSignal

abortSignal?: AbortSignal;

property AttachStderr

AttachStderr?: boolean | undefined;

property AttachStdin

AttachStdin?: boolean | undefined;

property AttachStdout

AttachStdout?: boolean | undefined;

property Cmd

Cmd?: string[] | undefined;

property Domainname

Domainname?: string | undefined;

property Entrypoint

Entrypoint?: string | string[] | undefined;

property Env

Env?: string[] | undefined;

property ExposedPorts

ExposedPorts?: { [port: string]: {} } | undefined;

property Healthcheck

Healthcheck?: HealthConfig | undefined;

property HostConfig

HostConfig?: HostConfig | undefined;

property Hostname

Hostname?: string | undefined;

property Image

Image?: string | undefined;

property Labels

Labels?: { [label: string]: string } | undefined;

property MacAddress

MacAddress?: boolean | undefined;

property name

name?: string | undefined;

property NetworkDisabled

NetworkDisabled?: boolean | undefined;

property NetworkingConfig

NetworkingConfig?:
    | {
          EndpointsConfig?: EndpointsConfig | undefined;
      }
    | undefined;

property OpenStdin

OpenStdin?: boolean | undefined;

property StdinOnce

StdinOnce?: boolean | undefined;

property StopSignal

StopSignal?: string | undefined;

property StopTimeout

StopTimeout?: number | undefined;

property Tty

Tty?: boolean | undefined;

property User

User?: string | undefined;

property Volumes

Volumes?: { [volume: string]: {} } | undefined;

property WorkingDir

WorkingDir?: string | undefined;

interface ContainerInfo

interface ContainerInfo {}

property Command

Command: string;

property Created

Created: number;

property HostConfig

HostConfig: {
    NetworkMode: string;
};

property Id

Id: string;

property Image

Image: string;

property ImageID

ImageID: string;

property Labels

Labels: { [label: string]: string };

property Mounts

Mounts: Array<{
    Name?: string | undefined;
    Type: string;
    Source: string;
    Destination: string;
    Driver?: string | undefined;
    Mode: string;
    RW: boolean;
    Propagation: string;
}>;

property Names

Names: string[];

property NetworkSettings

NetworkSettings: {
    Networks: { [networkType: string]: NetworkInfo };
};

property Ports

Ports: Port[];

property State

State: string;

property Status

Status: string;

interface ContainerInspectInfo

interface ContainerInspectInfo {}

property AppArmorProfile

AppArmorProfile: string;

property Args

Args: string[];

property Config

Config: {
    Hostname: string;
    Domainname: string;
    User: string;
    AttachStdin: boolean;
    AttachStdout: boolean;
    AttachStderr: boolean;
    ExposedPorts: { [portAndProtocol: string]: {} };
    Tty: boolean;
    OpenStdin: boolean;
    StdinOnce: boolean;
    Env: string[];
    Cmd: string[];
    Image: string;
    Volumes: { [volume: string]: {} };
    WorkingDir: string;
    Entrypoint?: string | string[] | undefined;
    OnBuild?: any;
    Labels: { [label: string]: string };
};

property Created

Created: string;

property Driver

Driver: string;

property ExecIDs

ExecIDs?: string[] | undefined;

property GraphDriver

GraphDriver: {
    Name: string;
    Data: {
        DeviceId: string;
        DeviceName: string;
        DeviceSize: string;
    };
};

property HostConfig

HostConfig: HostConfig;

property HostnamePath

HostnamePath: string;

property HostsPath

HostsPath: string;

property Id

Id: string;

property Image

Image: string;

property LogPath

LogPath: string;

property MountLabel

MountLabel: string;

property Mounts

Mounts: Array<{
    Name?: string | undefined;
    Source: string;
    Destination: string;
    Mode: string;
    RW: boolean;
    Propagation: string;
}>;

property Name

Name: string;

property NetworkSettings

NetworkSettings: {
    Bridge: string;
    SandboxID: string;
    HairpinMode: boolean;
    LinkLocalIPv6Address: string;
    LinkLocalIPv6PrefixLen: number;
    Ports: {
        [portAndProtocol: string]: Array<{
            HostIp: string;
            HostPort: string;
        }>;
    };
    SandboxKey: string;
    SecondaryIPAddresses?: any;
    SecondaryIPv6Addresses?: any;
    EndpointID: string;
    Gateway: string;
    GlobalIPv6Address: string;
    GlobalIPv6PrefixLen: number;
    IPAddress: string;
    IPPrefixLen: number;
    IPv6Gateway: string;
    MacAddress: string;
    Networks: {
        [type: string]: {
            IPAMConfig?: any;
            Links?: any;
            Aliases?: any;
            NetworkID: string;
            EndpointID: string;
            Gateway: string;
            IPAddress: string;
            IPPrefixLen: number;
            IPv6Gateway: string;
            GlobalIPv6Address: string;
            GlobalIPv6PrefixLen: number;
            MacAddress: string;
        };
    };
    Node?:
        | {
              ID: string;
              IP: string;
              Addr: string;
              Name: string;
              Cpus: number;
              Memory: number;
              Labels: any;
          }
        | undefined;
};

property Path

Path: string;

property Platform

Platform: string;

property ProcessLabel

ProcessLabel: string;

property ResolvConfPath

ResolvConfPath: string;

property RestartCount

RestartCount: number;

property State

State: {
    Status: string;
    Running: boolean;
    Paused: boolean;
    Restarting: boolean;
    OOMKilled: boolean;
    Dead: boolean;
    Pid: number;
    ExitCode: number;
    Error: string;
    StartedAt: string;
    FinishedAt: string;
    Health?:
        | {
              Status: string;
              FailingStreak: number;
              Log: Array<{
                  Start: string;
                  End: string;
                  ExitCode: number;
                  Output: string;
              }>;
          }
        | undefined;
};

interface ContainerLogsOptions

interface ContainerLogsOptions {}

property abortSignal

abortSignal?: AbortSignal;

property details

details?: boolean | undefined;

property follow

follow?: boolean | undefined;

property since

since?: number | undefined;

property stderr

stderr?: boolean | undefined;

property stdout

stdout?: boolean | undefined;

property tail

tail?: number | undefined;

property timestamps

timestamps?: boolean | undefined;

interface ContainerRemoveOptions

interface ContainerRemoveOptions {}

property force

force?: boolean | undefined;

property link

link?: boolean | undefined;

property v

v?: boolean | undefined;

interface ContainerSpec

interface ContainerSpec {}

property Args

Args?: string[] | undefined;

property CapabilityAdd

CapabilityAdd?: string[] | undefined;

property CapabilityDrop

CapabilityDrop?: string[] | undefined;

property Command

Command?: string[] | undefined;

property Dir

Dir?: string | undefined;

property DNSConfig

DNSConfig?: DNSConfig | undefined;

property Env

Env?: string[] | undefined;

property Groups

Groups?: string[] | undefined;

property HealthCheck

HealthCheck?: HealthConfig | undefined;

property Hostname

Hostname?: string | undefined;

property Hosts

Hosts?: string[] | undefined;

property Image

Image?: string | undefined;

property Init

Init?: boolean | undefined;

property Isolation

Isolation?: string | undefined;

property Labels

Labels?: { [label: string]: string } | undefined;

property Mounts

Mounts?: MountSettings[] | undefined;

property OpenStdin

OpenStdin?: boolean | undefined;

property Privileges

Privileges?: Privileges | undefined;

property ReadOnly

ReadOnly?: boolean | undefined;

property Secrets

Secrets?: SecretReference[] | undefined;

property StopGracePeriod

StopGracePeriod?: number | undefined;

property StopSignal

StopSignal?: string | undefined;

property Sysctls

Sysctls?: { [key: string]: string } | undefined;

property TTY

TTY?: boolean | undefined;

property Ulimits

Ulimits?: Ulimit[] | undefined;

property User

User?: string | undefined;

interface ContainerStats

interface ContainerStats {}

property blkio_stats

blkio_stats?: BlkioStats;

property cpu_stats

cpu_stats: CPUStats;

property memory_stats

memory_stats: MemoryStats;

property networks

networks: NetworkStats;

property num_procs

num_procs: number;

property pid_stats

pid_stats?: PidsStats;

property precpu_stats

precpu_stats: CPUStats;

property preread

preread: string;

property read

read: string;

property storage_stats

storage_stats?: StorageStats;

interface ContainerTaskSpec

interface ContainerTaskSpec extends TaskSpecBase {}

property ContainerSpec

ContainerSpec?: ContainerSpec | undefined;

interface ContainerWaitOptions

interface ContainerWaitOptions {}

property abortSignal

abortSignal?: AbortSignal;

property condition

condition?: 'not-running' | 'next-exit' | 'removed' | undefined;

Since v1.30

interface CPUStats

interface CPUStats {}

property cpu_usage

cpu_usage: CPUUsage;

property online_cpus

online_cpus: number;

property system_cpu_usage

system_cpu_usage: number;

property throttling_data

throttling_data: ThrottlingData;

interface CPUUsage

interface CPUUsage {}

property percpu_usage

percpu_usage: number[];

property total_usage

total_usage: number;

property usage_in_kernelmode

usage_in_kernelmode: number;

property usage_in_usermode

usage_in_usermode: number;

interface CreateServiceOptions

interface CreateServiceOptions extends ServiceSpec {}

property abortSignal

abortSignal?: AbortSignal;

property authconfig

authconfig?: AuthConfig | undefined;

interface DeviceMapping

interface DeviceMapping {}

property CgroupPermissions

CgroupPermissions: string;

property PathInContainer

PathInContainer: string;

property PathOnHost

PathOnHost: string;

interface DeviceRequest

interface DeviceRequest {}

property Capabilities

Capabilities?: string[][] | undefined;

property Count

Count?: number | undefined;

property DeviceIDs

DeviceIDs?: string[] | undefined;

property Driver

Driver?: string | undefined;

property Options

Options?: { [key: string]: string } | undefined;

interface DiscreteGenericResource

interface DiscreteGenericResource {}

property Kind

Kind?: string | undefined;

property Value

Value?: number | undefined;

interface DispatcherConfig

interface DispatcherConfig {}

property HeartbeatPeriod

HeartbeatPeriod?: Duration | undefined;

interface DNSConfig

interface DNSConfig {}

property Nameservers

Nameservers?: string[] | undefined;

property Options

Options?: string[] | undefined;

property Search

Search?: string[] | undefined;

interface DockerOptions

interface DockerOptions {}

property ca

ca?: string | string[] | Buffer | Buffer[] | undefined;

property cert

cert?: string | string[] | Buffer | Buffer[] | undefined;

property host

host?: string | undefined;

property key

key?: string | string[] | Buffer | Buffer[] | KeyObject[] | undefined;

property port

port?: number | string | undefined;

property Promise

Promise?: typeof Promise | undefined;

property protocol

protocol?: 'https' | 'http' | 'ssh' | undefined;

property socketPath

socketPath?: string | undefined;

property sshAuthAgent

sshAuthAgent?: string | undefined;

property timeout

timeout?: number | undefined;

property username

username?: string | undefined;

property version

version?: string | undefined;

interface DockerVersion

interface DockerVersion {}

property ApiVersion

ApiVersion: string;

property Arch

Arch: string;

property BuildTime

BuildTime: Date;

property Components

Components: Array<{
    Details: {
        ApiVersion: string;
        Arch: string;
        BuildTime: Date;
        Experimental: string;
        GitCommit: string;
        GoVersion: string;
        KernelVersion: string;
        Os: string;
    };
    Name: string;
    Version: string;
}>;

property GitCommit

GitCommit: string;

property GoVersion

GoVersion: string;

property KernelVersion

KernelVersion: string;

property MinAPIVersion

MinAPIVersion: string;

property Os

Os: string;

property Platform

Platform: {
    Name: string;
};

property Version

Version: string;

interface Driver

interface Driver {}

property Name

Name: string;

property Options

Options?: { [key: string]: string } | undefined;

interface EncryptionConfig

interface EncryptionConfig {}

property AutoLockManagers

AutoLockManagers: boolean;

interface Endpoint

interface Endpoint {}

property Ports

Ports?: PortConfig[] | undefined;

property Spec

Spec?: EndpointSpec | undefined;

property VirtualIPs

VirtualIPs?: EndpointVirtualIP[] | undefined;

interface EndpointsConfig

interface EndpointsConfig {}

index signature

[key: string]: EndpointSettings;

interface EndpointSettings

interface EndpointSettings {}

property Aliases

Aliases?: string[] | undefined;

property DriverOpts

DriverOpts?: { [key: string]: string } | undefined;

property EndpointID

EndpointID?: string | undefined;

property Gateway

Gateway?: string | undefined;

property GlobalIPv6Address

GlobalIPv6Address?: string | undefined;

property GlobalIPV6PrefixLen

GlobalIPV6PrefixLen?: number | undefined;

property IPAddress

IPAddress?: string | undefined;

property IPAMConfig

IPAMConfig?: IPAMConfig | undefined;

property IPPrefixLen

IPPrefixLen?: number | undefined;

property IPv6Gateway

IPv6Gateway?: string | undefined;

property Links

Links?: string[] | undefined;

property MacAddress

MacAddress?: string | undefined;

property NetworkID

NetworkID?: string | undefined;

interface EndpointSpec

interface EndpointSpec {}

property Mode

Mode?: string | undefined;

property Ports

Ports?: PortConfig[] | undefined;

interface EndpointVirtualIP

interface EndpointVirtualIP {}

property Addr

Addr?: string | undefined;

property NetworkID

NetworkID?: string | undefined;

interface ExecCreateOptions

interface ExecCreateOptions {}

property abortSignal

abortSignal?: AbortSignal;

property AttachStderr

AttachStderr?: boolean | undefined;

property AttachStdin

AttachStdin?: boolean | undefined;

property AttachStdout

AttachStdout?: boolean | undefined;

property Cmd

Cmd?: string[] | undefined;

property DetachKeys

DetachKeys?: string | undefined;

property Env

Env?: string[] | undefined;

property Privileged

Privileged?: boolean | undefined;

property Tty

Tty?: boolean | undefined;

property User

User?: string | undefined;

property WorkingDir

WorkingDir?: string | undefined;

interface ExecInspectInfo

interface ExecInspectInfo {}

property CanRemove

CanRemove: boolean;

property ContainerID

ContainerID: string;

property DetachKeys

DetachKeys: string;

property ExitCode

ExitCode: number | null;

property ID

ID: string;

property OpenStderr

OpenStderr: boolean;

@types/dockerode

Install

Overview

Index

Classes

Interfaces

Type Aliases

Classes

class Config

property id

property modem

method inspect

method remove

method update

class Container

property id

property modem

method attach

method changes

method commit

method copy

method exec

method export

method getArchive

method infoArchive

method inspect

method kill

method logs

method pause

method putArchive

Parameter file

method remove

method rename

method resize

method restart

method start

method stats

method stop

method top

method unpause

method update

method wait

class Dockerode

property modem

method buildImage

method checkAuth

method createConfig

method createContainer

method createImage

method createNetwork

method createPlugin

method createSecret

method createService

method createVolume

method df

method getConfig

method getContainer

method getEvents

method getExec

method getImage

method getNetwork

method getNode

method getPlugin

method getSecret

method getService

method getTask

method getVolume

method importImage

method info

method listConfigs

method listContainers

method listImages

method listNetworks

method listNodes

method listPlugins

method listSecrets

method listServices

method listTasks

method listVolumes

method loadImage