@types/dockerode

Version 3.3.41
Published 5 days ago
78.7 kB
3 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: ContainerAttachOptions,
        callback: Callback<NodeJS.ReadWriteStream>
    ): void;
    (options: ContainerAttachOptions): 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: ContainerInspectOptions,
        callback: Callback<ContainerInspectInfo>
    ): void;
    (callback: Callback<ContainerInspectInfo>): void;
    (options?: ContainerInspectOptions): Promise<ContainerInspectInfo>;
};

method kill

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

method logs

logs: {
    (
        options: ContainerLogsOptions & { follow?: false },
        callback: Callback<Buffer>
    ): void;
    (
        options: ContainerLogsOptions & { follow: true },
        callback: Callback<NodeJS.ReadableStream>
    ): void;
    (callback: Callback<Buffer>): void;
    (options?: ContainerLogsOptions & { follow?: false }): Promise<Buffer>;
    (
        options?: ContainerLogsOptions & { follow: true }
    ): 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: ContainerStartOptions, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: ContainerStartOptions): Promise<any>;
};

method stats

stats: {
    (
        options: { stream?: false; 'one-shot'?: boolean },
        callback: Callback<ContainerStats>
    ): void;
    (options: { stream: true }, callback: Callback<NodeJS.ReadableStream>): void;
    (callback: Callback<ContainerStats>): void;
    (options?: {
        stream?: false;
        'one-shot'?: boolean;
    }): Promise<ContainerStats>;
    (options?: { stream: true }): Promise<NodeJS.ReadableStream>;
};

method stop

stop: {
    (options: ContainerStopOptions, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: ContainerStopOptions): 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.Service>
    ): void;
    (options: Dockerode.CreateServiceOptions): Promise<Dockerode.Service>;
    (
        auth: Dockerode.AuthConfig,
        options: Dockerode.ServiceSpec
    ): Promise<Dockerode.Service>;
};

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: Dockerode.ContainerListOptions,
        callback: Callback<Dockerode.ContainerInfo[]>
    ): void;
    (callback: Callback<Dockerode.ContainerInfo[]>): void;
    (options?: Dockerode.ContainerListOptions): 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: Dockerode.NetworkListOptions,
        callback: Callback<Dockerode.NetworkInspectInfo[]>
    ): void;
    (callback: Callback<Dockerode.NetworkInspectInfo[]>): void;
    (options?: Dockerode.NetworkListOptions): Promise<
        Dockerode.NetworkInspectInfo[]
    >;
};

method listNodes

listNodes: {
    (options: Dockerode.NodeListOptions, callback: Callback<any[]>): void;
    (callback: Callback<any[]>): void;
    (options?: Dockerode.NodeListOptions): 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: Dockerode.VolumeListOptions,
        callback: Callback<{
            Volumes: Dockerode.VolumeInspectInfo[];
            Warnings: string[];
        }>
    ): void;
    (
        callback: Callback<{
            Volumes: Dockerode.VolumeInspectInfo[];
            Warnings: string[];
        }>
    ): void;
    (options?: Dockerode.VolumeListOptions): 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: Dockerode.VolumePruneOptions,
        callback: Callback<Dockerode.PruneVolumesInfo>
    ): void;
    (callback: Callback<Dockerode.PruneVolumesInfo>): void;
    (
        options?: Dockerode.VolumePruneOptions
    ): Promise<Dockerode.PruneVolumesInfo>;
};

method pull

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

method run

run: {
    (
        image: string,
        cmd: string[],
        outputStream: NodeJS.WritableStream | NodeJS.WritableStream[],
        createOptions: Dockerode.ContainerCreateOptions,
        startOptions: Dockerode.ContainerStartOptions,
        callback: Callback<any>
    ): events.EventEmitter;
    (
        image: string,
        cmd: string[],
        outputStream: any,
        createOptions: Dockerode.ContainerCreateOptions,
        callback: Callback<any>
    ): events.EventEmitter;
    (
        image: string,
        cmd: string[],
        outputStream: any,
        callback: Callback<any>
    ): events.EventEmitter;
    (
        image: string,
        cmd: string[],
        outputStream: any,
        createOptions?: Dockerode.ContainerCreateOptions,
        startOptions?: Dockerode.ContainerStartOptions
    ): 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: {
    (options: ExecInspectOptions, callback: Callback<ExecInspectInfo>): void;
    (callback: Callback<ExecInspectInfo>): void;
    (options?: ExecInspectOptions): 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: {
    (options: ImageInspectOptions, callback: Callback<ImageInspectInfo>): void;
    (callback: Callback<ImageInspectInfo>): void;
    (options?: ImageInspectOptions): 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: ImageTagOptions, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: ImageTagOptions): Promise<any>;
};

class Network

class Network {}

constructor

constructor(modem: any, id: string);

property id

id: string;

property modem

modem: any;

method connect

connect: {
    (options: NetworkConnectOptions, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: NetworkConnectOptions): 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: VolumeRemoveOptions, callback: Callback<any>): void;
    (callback: Callback<any>): void;
    (options?: VolumeRemoveOptions): 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 auth

auth?: string;

property email

email?: string | undefined;

Deprecated

property identitytoken

identitytoken?: string;

property password

password?: string;

property registrytoken

registrytoken?: 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 ConfigReference

interface ConfigReference {}

property ConfigID

ConfigID?: string | undefined;

property ConfigName

ConfigName?: string | undefined;

property File

File?:
    | {
          Name?: string | undefined;
          UID?: string | undefined;
          GID?: string | undefined;
          Mode: number | undefined;
      }
    | undefined;

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 ContainerAttachOptions

interface ContainerAttachOptions {}

property abortSignal

abortSignal?: AbortSignal;

property detachKeys

detachKeys?: string | undefined;

property hijack

hijack?: boolean | undefined;

property logs

logs?: boolean | undefined;

property stderr

stderr?: boolean | undefined;

property stdin

stdin?: boolean | undefined;

property stdout

stdout?: boolean | undefined;

property stream

stream?: boolean | undefined;

interface ContainerCreateOptions

interface ContainerCreateOptions {}

property abortSignal

abortSignal?: AbortSignal;

property ArgsEscaped

ArgsEscaped?: boolean | undefined;

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?: string | undefined;

property name

name?: string | undefined;

property NetworkDisabled

NetworkDisabled?: boolean | undefined;

property NetworkingConfig

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

property OnBuild

OnBuild?: string[] | undefined;

property OpenStdin

OpenStdin?: boolean | undefined;

property platform

platform?: string | undefined;

property Shell

Shell?: string[] | 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<{
    Type: 'bind' | 'volume' | 'image' | 'tmpfs' | 'npipe' | 'cluster';
    Name?: string | undefined;
    Source: string;
    Destination: string;
    Driver?: string | undefined;
    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 ContainerInspectOptions

interface ContainerInspectOptions {}

property abortSignal

abortSignal?: AbortSignal;

interface ContainerListOptions

interface ContainerListOptions {}

property abortSignal

abortSignal?: AbortSignal;

property all

all?: boolean;

Return all containers. By default, only running containers are shown false

property filters

filters?: string | { [key: string]: string[] };

Filters to process on the container list, encoded as JSON (a map[string][]string). A dictionary of key/value list is also accepted.

property limit

limit?: number;

Return this number of most recently created containers, including non-running ones.

property size

size?: boolean;

Return the size of container as fields SizeRw and SizeRootFs. false

interface ContainerLogsOptions

interface ContainerLogsOptions {}

property abortSignal

abortSignal?: AbortSignal;

property details

details?: boolean | undefined;

property follow

follow?: boolean | undefined;

property since

since?: number | string | undefined;

property stderr

stderr?: boolean | undefined;

property stdout

stdout?: boolean | undefined;

property tail

tail?: number | undefined;

property timestamps

timestamps?: boolean | undefined;

property until

until?: number | string | 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 Configs

Configs?: ConfigReference[] | 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 ContainerStartOptions

interface ContainerStartOptions {}

property abortSignal

abortSignal?: AbortSignal;

property detachKeys

detachKeys?: string;

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 pids_stats

pids_stats?: PidsStats;

property precpu_stats

precpu_stats: CPUStats;

property preread

preread: string;

property read

read: string;

property storage_stats

storage_stats?: StorageStats;

interface ContainerStopOptions

interface ContainerStopOptions {}

property abortSignal

abortSignal?: AbortSignal;

property signal

signal?: string;

property t

t?: number;

Number of seconds to wait before killing the container

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 headers

headers?: { [name: string]: string };

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 sshOptions

sshOptions?: ConnectConfig | 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 ConsoleSize

ConsoleSize?: [number, number];

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;

property OpenStdin

OpenStdin: boolean;

property OpenStdout

OpenStdout: boolean;

property Pid

Pid: number;

property ProcessConfig

ProcessConfig: {
    privileged: boolean;
    user: string;
    tty: boolean;
    entrypoint: string;
    arguments: string[];
};

property Running

Running: boolean;

interface ExecInspectOptions

interface ExecInspectOptions {}

property abortSignal

abortSignal?: AbortSignal;

interface ExecStartOptions

interface ExecStartOptions {}

property abortSignal

abortSignal?: AbortSignal;

property Detach

Detach?: boolean | undefined;

property hijack

hijack?: boolean | undefined;

property stdin

stdin?: boolean | undefined;

property Tty

Tty?: boolean | undefined;

interface ExternalCA

interface ExternalCA {}

property CACert

CACert: string;

property Options

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

property Protocol

Protocol: ExternalCAProtocol;

property URL

URL: string;

interface GetEventsOptions

interface GetEventsOptions {}

property abortSignal

abortSignal?: AbortSignal;

property filters

filters?:
    | string
    | {
          config?: string | undefined;
          container?: string[] | undefined;
          daemon?: string[] | undefined;
          event?: string[] | undefined;
          image?: string[] | undefined;
          label?: string[] | undefined;
          network?: string[] | undefined;
          node?: string[] | undefined;
          plugin?: string[] | undefined;
          scope?: Array<'local' | 'swarm'> | undefined;
          secret?: string[] | undefined;
          service?: string[] | undefined;
          type?:
              | Array<
                    | 'container'
                    | 'image'
                    | 'volume'
                    | 'network'
                    | 'daemon'
                    | 'plugin'
                    | 'service'
                    | 'node'
                    | 'secret'
                    | 'config'
                >
              | undefined;
          volume?: string[] | undefined;
      }
    | undefined;

property since

since?: number | undefined;

property until

until?: number | undefined;

interface HealthConfig

interface HealthConfig {}

property Interval

Interval?: number | undefined;

property Retries

Retries?: number | undefined;

property StartInterval

StartInterval?: number | undefined;

property StartPeriod

StartPeriod?: number | undefined;

property Test

Test?: string[] | undefined;

property Timeout

Timeout?: number | undefined;

interface HostConfig

interface HostConfig {}

property AutoRemove

AutoRemove?: boolean | undefined;

property Binds

Binds?: string[] | undefined;

property BlkioDeviceReadBps

BlkioDeviceReadBps?: any;

property BlkioDeviceReadIOps

BlkioDeviceReadIOps?: any;

property BlkioDeviceWriteBps

BlkioDeviceWriteBps?: any;

property BlkioDeviceWriteIOps

BlkioDeviceWriteIOps?: any;

property BlkioWeight

BlkioWeight?: number | undefined;

property BlkioWeightDevice

BlkioWeightDevice?: any;

property CapAdd

CapAdd?: any;

property CapDrop

CapDrop?: any;

property Cgroup

Cgroup?: string | undefined;

property CgroupParent

CgroupParent?: string | undefined;

property ConsoleSize

ConsoleSize?: number[] | undefined;

property ContainerIDFile

ContainerIDFile?: string | undefined;

property CpuCount

CpuCount?: number | undefined;

property CpuPercent

CpuPercent?: number | undefined;

property CpuPeriod

CpuPeriod?: number | undefined;

property CpuQuota

CpuQuota?: number | undefined;

property CpuRealtimePeriod

CpuRealtimePeriod?: number | undefined;

property CpuRealtimeRuntime

CpuRealtimeRuntime?: number | undefined;

property CpusetCpus

CpusetCpus?: string | undefined;

property CpusetMems

CpusetMems?: string | undefined;

property CpuShares

CpuShares?: number | undefined;

property DeviceCgroupRules

DeviceCgroupRules?: string[] | undefined;

property DeviceRequests

DeviceRequests?: DeviceRequest[] | undefined;

property Devices

Devices?: any;

property DiskQuota

DiskQuota?: number | undefined;

property Dns

Dns?: any[] | undefined;

property DnsOptions

DnsOptions?: any[] | undefined;

property DnsSearch

DnsSearch?: string[] | undefined;

property ExtraHosts

ExtraHosts?: any;

property GroupAdd

GroupAdd?: string[] | undefined;

property Init

Init?: boolean | undefined;

property IpcMode

IpcMode?: string | undefined;

property Isolation

Isolation?: string | undefined;

property KernelMemory

KernelMemory?: number | undefined;

property Links

Links?: any;

property LogConfig

LogConfig?:
    | {
          Type: string;
          Config: any;
      }
    | undefined;

property MaskedPaths

MaskedPaths?: string[] | undefined;

property Memory

Memory?: number | undefined;

property MemoryReservation

MemoryReservation?: number | undefined;

property MemorySwap

MemorySwap?: number | undefined;

property MemorySwappiness

MemorySwappiness?: number | undefined;

property Mounts

Mounts?: MountConfig | undefined;

property NanoCpus

NanoCpus?: number | undefined;

property NetworkMode

NetworkMode?: string | undefined;

property OomKillDisable

OomKillDisable?: boolean | undefined;

property OomScoreAdj

OomScoreAdj?: number | undefined;

property PidMode

PidMode?: string | undefined;

property PidsLimit

PidsLimit?: number | undefined;

property PortBindings

PortBindings?: any;

property Privileged

Privileged?: boolean | undefined;

property PublishAllPorts

PublishAllPorts?: boolean | undefined;

property ReadonlyPaths

ReadonlyPaths?: string[] | undefined;

property ReadonlyRootfs

ReadonlyRootfs?: boolean | undefined;

property RestartPolicy

RestartPolicy?: HostRestartPolicy | undefined;

property Runtime

Runtime?: string | undefined;

property SecurityOpt

SecurityOpt?: any;

property ShmSize

ShmSize?: number | undefined;

property StorageOpt

StorageOpt?: { [option: string]: string } | undefined;

property Sysctls

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

property Tmpfs

Tmpfs?: { [dir: string]: string } | undefined;

property Ulimits

Ulimits?: Ulimit[] | undefined;

property UsernsMode

UsernsMode?: string | undefined;

property UTSMode

UTSMode?: string | undefined;

property VolumeDriver

VolumeDriver?: string | undefined;

property VolumesFrom

VolumesFrom?: any;

interface HostRestartPolicy

interface HostRestartPolicy {}

property MaximumRetryCount

MaximumRetryCount?: number | undefined;

property Name

Name: string;

interface ImageBuildContext

interface ImageBuildContext {}

property context

context: string;

property src

src: string[];

interface ImageBuildOptions

interface ImageBuildOptions {}

property abortSignal

abortSignal?: AbortSignal;

property authconfig

authconfig?: AuthConfig | undefined;

property buildargs

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

property cachefrom

cachefrom?: string | undefined;

property cpuperiod

cpuperiod?: number | undefined;

property cpuquota

cpuquota?: number | undefined;

property cpusetcpus

cpusetcpus?: number | undefined;

property cpushares

cpushares?: number | undefined;

property dockerfile

dockerfile?: string | undefined;

property extrahosts

extrahosts?: string | undefined;

property forcerm

forcerm?: boolean | undefined;

property labels

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

property memory

memory?: number | undefined;

property memswap

memswap?: number | undefined;

property networkmode

networkmode?: string | undefined;

property nocache

nocache?: boolean | undefined;

property outputs

outputs?: string | undefined;

property platform

platform?: string | undefined;

property pull

pull?: boolean | undefined;

property q

q?: boolean | undefined;

property registryconfig

registryconfig?: RegistryConfig | undefined;

property remote

remote?: string | undefined;

property rm

rm?: boolean | undefined;

property shmsize

shmsize?: number | undefined;

property squash

squash?: boolean | undefined;

property t

t?: string | undefined;

property target

target?: string | undefined;

property version

version?: '1' | '2' | undefined;

Version of the builder backend to use. - 1 is the first generation classic (deprecated) builder in the Docker daemon (default) - 2 is [BuildKit](https://github.com/moby/buildkit)

interface ImageDescriptor

interface ImageDescriptor {}

property annotations

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

property artifactType

artifactType?: string | undefined;

property data

data?: string | undefined;

property digest

digest: string;

property mediaType

mediaType: string;

property platform

platform?:
    | {
          architecture: string;
          os: string;
          'os.version'?: string | undefined;
          'os.features'?: string[] | undefined;
          variant?: string | undefined;
      }
    | undefined;

property size

size: number;

property urls

urls?: string[] | undefined;

interface ImageDistributionDescriptorInfo

interface ImageDistributionDescriptorInfo {}

property digest

digest: string;

property mediaType

mediaType: string;

property size

size: number;

interface ImageDistributionInfo

interface ImageDistributionInfo {}

property Descriptor

Descriptor: ImageDistributionDescriptorInfo;

property Platforms

Platforms: ImageDistributionPlatformInfo[];

interface ImageDistributionOptions

interface ImageDistributionOptions {}

property abortSignal

abortSignal?: AbortSignal;

property authconfig

authconfig?: AuthConfig | undefined;

interface ImageDistributionPlatformInfo

interface ImageDistributionPlatformInfo {}

property "os.features"

'os.features': string[];

property "os.version"

'os.version': string;

property architecture

architecture: string;

property os

os: string;

property variant

variant: string;

interface ImageInfo

interface ImageInfo {}

property Containers

Containers: number;

property Created

Created: number;

property Descriptor

Descriptor?: ImageDescriptor | undefined;

property Id

Id: string;

property Labels

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

property Manifests

Manifests?:
    | {
          ID: string;
          Descriptor: ImageDescriptor;
          Available: boolean;
          Size: {
              Total: number;
              Content: number;
          };
          Kind: 'image' | 'attestation' | 'unknown';
          ImageData?:
              | {
                    Platform: {
                        architecture: string;
                        os: string;
                        'os.version'?: string | undefined;
                        'os.features'?: string[] | undefined;
                        variant?: string | undefined;
                    };
                    Containers: string[];
                    Size: {
                        Unpacked: number;
                    };
                }
              | undefined;
          AttestationData?:
              | {
                    For: string;
                }
              | undefined;
      }[]
    | undefined;

property ParentId

ParentId: string;

property RepoDigests

RepoDigests?: string[] | undefined;

property RepoTags

RepoTags: string[] | undefined;

property SharedSize

SharedSize: number;

property Size

Size: number;

property VirtualSize

VirtualSize: number;

interface ImageInspectInfo

interface ImageInspectInfo {}

property Architecture

Architecture: string;

property Author

Author: string;

property Comment

Comment: 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[];
    ArgsEscaped: boolean;
    Image: string;
    Volumes: { [path: string]: {} };
    WorkingDir: string;
    Entrypoint?: string | string[] | undefined;
    OnBuild: any[];
    Labels: { [label: string]: string };
};

property Container

Container: string;

property ContainerConfig

ContainerConfig: {
    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[];
    ArgsEscaped: boolean;
    Image: string;
    Volumes: { [path: string]: {} };
    WorkingDir: string;
    Entrypoint?: string | string[] | undefined;
    OnBuild?: any[] | undefined;
    Labels: { [label: string]: string };
};

property Created

Created: string;

property Descriptor

Descriptor?:
    | {
          mediaType: string;
          digest: string;
          size: number;
          urls?: string[] | undefined;
          annotations?: { [key: string]: string } | undefined;
          data?: string | undefined;
          platform?:
              | {
                    architecture: string;
                    os: string;
                    'os.version'?: string | undefined;
                    'os.features'?: string[] | undefined;
                    variant?: string | undefined;
                }
              | undefined;
          artifactType?: string | undefined;
      }
    | undefined;

property DockerVersion

DockerVersion: string;

property GraphDriver

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

property Id

Id: string;

property Manifests

Manifests?:
    | {
          ID: string;
          Descriptor: {
              mediaType: string;
              digest: string;
              size: number;
              urls?: string[] | undefined;
              annotations?: { [key: string]: string } | undefined;
              data?: string | undefined;
              platform?:
                  | {
                        architecture: string;
                        os: string;
                        'os.version'?: string | undefined;
                        'os.features'?: string[] | undefined;
                        variant?: string | undefined;
                    }
                  | undefined;
              artifactType?: string | undefined;
          };
          Available: boolean;
          Size: {
              Total: number;
              Content: number;
          };
          Kind: 'image' | 'attestation' | 'unknown';
          ImageData?:
              | {
                    Platform: {
                        architecture: string;
                        os: string;
                        'os.version'?: string | undefined;
                        'os.features'?: string[] | undefined;
                        variant?: string | undefined;
                    };
                    Containers: string[];
                    Size: {
                        Total: number;
                        Content: number;
                    };
                }
              | undefined;
          AttestationData?:
              | {
                    For: string;
                }
              | undefined;
      }[]
    | undefined;

property Os

Os: string;

property OsVersion

OsVersion?: string | undefined;

property Parent

Parent: string;

property RepoDigests

RepoDigests: string[];

property RepoTags

RepoTags: string[];

property RootFS

RootFS: {
    Type: string;
    Layers?: string[] | undefined;
    BaseLayer?: string | undefined;
};

property Size

Size: number;

property Variant

Variant?: string | undefined;

property VirtualSize

VirtualSize: number;

interface ImageInspectOptions

interface ImageInspectOptions {}

property manifests

manifests?: boolean | undefined;

interface ImagePushOptions

interface ImagePushOptions {}

property abortSignal

abortSignal?: AbortSignal;

property authconfig

authconfig?: AuthConfig | undefined;

property tag

tag?: string | undefined;

interface ImageRemoveInfo

interface ImageRemoveInfo {}

property Deleted

Deleted: string;

property Untagged

Untagged: string;

interface ImageRemoveOptions

interface ImageRemoveOptions {}

property abortSignal

abortSignal?: AbortSignal;

property force

force?: boolean | undefined;

property noprune

noprune?: boolean | undefined;

interface ImageTagOptions

interface ImageTagOptions {}

property abortSignal

abortSignal?: AbortSignal;

property repo

repo: string;

The repository to tag in. For example, someuser/someimage.

property tag

tag?: string;

The name of the new tag.

interface Interface

interface Interface {}

property Socket

Socket: string;

property Types

Types: PluginInterfaceType[];

interface IPAM

interface IPAM {}

property Config

Config?:
    | Array<{
          Subnet?: string | undefined;
          IPRange?: string | undefined;
          Gateway?: string | undefined;
          AuxiliaryAddresses?: Partial<{ [host: string]: string }> | undefined;
      }>
    | undefined;

property Driver

Driver?: string;

property Options

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

interface IPAMConfig

interface IPAMConfig {}

property IPv4Address

IPv4Address?: string | undefined;

property IPv6Address

IPv6Address?: string | undefined;

property LinkLocalIPs

LinkLocalIPs?: string[] | undefined;

interface JobStatus

interface JobStatus {}

property JobIteration

JobIteration: Version;

property LastExecution

LastExecution?: string | undefined;

interface JoinTokens

interface JoinTokens {}

property Manager

Manager: string;

property Worker

Worker: string;

interface KeyObject

interface KeyObject {}

property passphrase

passphrase?: string | undefined;

property pem

pem: string | Buffer;

interface Linux

interface Linux {}

property AllowAllDevices

AllowAllDevices: boolean;

property Capabilities

Capabilities: string[];

property Devices

Devices: PluginDevice[];

interface ListImagesOptions

interface ListImagesOptions {}

property abortSignal

abortSignal?: AbortSignal;

property all

all?: boolean | undefined;

property digests

digests?: boolean | undefined;

property filters

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

property manifests

manifests?: boolean | undefined;

interface LogConfig

interface LogConfig {}

property Config

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

property Type

Type: LoggingDriverType;

interface MemoryStats

interface MemoryStats {}

property commitbytes

commitbytes?: number;

property commitpeakbytes

commitpeakbytes?: number;

property failcnt

failcnt: number;

property limit

limit: number;

property max_usage

max_usage: number;

property privateworkingset

privateworkingset?: number;

property stats

stats: {
    total_pgmajfault: number;
    cache: number;
    mapped_file: number;
    total_inactive_file: number;
    pgpgout: number;
    rss: number;
    total_mapped_file: number;
    writeback: number;
    unevictable: number;
    pgpgin: number;
    total_unevictable: number;
    pgmajfault: number;
    total_rss: number;
    total_rss_huge: number;
    total_writeback: number;
    total_inactive_anon: number;
    rss_huge: number;
    hierarchical_memory_limit: number;
    total_pgfault: number;
    total_active_file: number;
    active_anon: number;
    total_active_anon: number;
    total_pgpgout: number;
    total_cache: number;
    inactive_anon: number;
    active_file: number;
    pgfault: number;
    inactive_file: number;
    total_pgpgin: number;
};

property usage

usage: number;

interface Meta

interface Meta {}

property CreatedAt

CreatedAt?: string | undefined;

property UpdatedAt

UpdatedAt?: string | undefined;

property Version

Version?: Version | undefined;

interface MountSettings

interface MountSettings {}

property BindOptions

BindOptions?:
    | {
          Propagation: MountPropagation;
      }
    | undefined;

property Consistency

Consistency?: MountConsistency | undefined;

property ImageOptions

ImageOptions?:
    | {
          Subpath?: string;
      }
    | undefined;

property ReadOnly

ReadOnly?: boolean | undefined;

property Source

Source: string;

property Target

Target: string;

property TmpfsOptions

TmpfsOptions?:
    | {
          SizeBytes: number;
          Mode: number;
      }
    | undefined;

property Type

Type: MountType;

property VolumeOptions

VolumeOptions?:
    | {
          NoCopy: boolean;
          Labels: { [label: string]: string };
          DriverConfig: {
              Name: string;
              Options: { [option: string]: string };
          };
          Subpath?: string;
      }
    | undefined;

interface NamedGenericResource

interface NamedGenericResource {}

property Kind

Kind?: string | undefined;

property Value

Value?: string | undefined;

interface Network

interface Network {}

property Type

Type: string;

interface NetworkAttachmentConfig

interface NetworkAttachmentConfig {}

property Aliases

Aliases?: string[] | undefined;

property DriverOpts

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

property Target

Target?: string | undefined;

interface NetworkAttachmentTaskSpec

interface NetworkAttachmentTaskSpec extends TaskSpecBase {}

property NetworkAttachmentSpec

NetworkAttachmentSpec: {
    ContainerID: string;
};

property Runtime

Runtime: 'attachment';

interface NetworkConnectOptions

interface NetworkConnectOptions {}

property Container

Container?: string;

property EndpointConfig

EndpointConfig?: EndpointSettings | undefined;

interface NetworkContainer

interface NetworkContainer {}

property EndpointID

EndpointID: string;

property IPv4Address

IPv4Address: string;

property IPv6Address

IPv6Address: string;

property MacAddress

MacAddress: string;

property Name

Name: string;

interface NetworkCreateOptions

interface NetworkCreateOptions {}

property abortSignal

abortSignal?: AbortSignal;

property Attachable

Attachable?: boolean | undefined;

property CheckDuplicate

CheckDuplicate?: boolean | undefined;

property ConfigFrom

ConfigFrom?: { Network?: string } | undefined;

property ConfigOnly

ConfigOnly?: boolean | undefined;

property Driver

Driver?: string | undefined;

property EnableIPv4

EnableIPv4?: boolean | undefined;

property EnableIPv6

EnableIPv6?: boolean | undefined;

property Ingress

Ingress?: boolean | undefined;

property Internal

Internal?: boolean | undefined;

property IPAM

IPAM?: IPAM | undefined;

property Labels

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

property Name

Name: string;

property Options

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

property Scope

Scope?: string | undefined;

interface NetworkInfo

interface NetworkInfo {}

property Aliases

Aliases?: any;

property EndpointID

EndpointID: string;

property Gateway

Gateway: string;

property GlobalIPv6Address

GlobalIPv6Address: string;

property GlobalIPv6PrefixLen

GlobalIPv6PrefixLen: number;

property IPAddress

IPAddress: string;

property IPAMConfig

IPAMConfig?: any;

property IPPrefixLen

IPPrefixLen: number;

property IPv6Gateway

IPv6Gateway: string;

property Links

Links?: any;

property MacAddress

MacAddress: string;

property NetworkID

NetworkID: string;

interface NetworkInspectInfo

interface NetworkInspectInfo {}

property Attachable

Attachable: boolean;

property ConfigFrom

ConfigFrom?: { Network: string } | undefined;

property ConfigOnly

ConfigOnly: boolean;

property Containers

Containers?: { [id: string]: NetworkContainer } | undefined;

property Created

Created: string;

property Driver

Driver: string;

property EnableIPv6

EnableIPv6: boolean;

property Id

Id: string;

property Ingress

Ingress: boolean;

property Internal

Internal: boolean;

property IPAM

IPAM?: IPAM | undefined;

property Labels

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

property Name

Name: string;

property Options

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

property Scope

Scope: string;

interface NetworkListOptions

interface NetworkListOptions {}

property abortSignal

abortSignal?: AbortSignal;

property filters

filters?: string | { [key: string]: string[] };

JSON encoded value of the filters (a map[string][]string) to process on the networks list. A dictionary of key/value list is also accepted.

interface NetworkStats

interface NetworkStats {}

index signature

[name: string]: {
    rx_bytes: number;
    rx_dropped: number;
    rx_errors: number;
    rx_packets: number;
    tx_bytes: number;
    tx_dropped: number;
    tx_errors: number;
    tx_packets: number;
    endpoint_id?: string; // not used on linux
    instance_id?: string; // not used on linux
};

interface NodeListOptions

interface NodeListOptions {}

property abortSignal

abortSignal?: AbortSignal;

property filters

filters?: string;

Filters to process on the nodes list, encoded as JSON (a map[string][]string).

interface OrchestrationConfig

interface OrchestrationConfig {}

property TaskHistoryRetentionLimit

TaskHistoryRetentionLimit?: number | undefined;

interface PidsStats

interface PidsStats {}

property current

current?: number;

property limit

limit?: number;

interface Placement

interface Placement {}

property Constraints

Constraints?: string[] | undefined;

property MaxReplicas

MaxReplicas?: number | undefined;

property Platforms

Platforms?:
    | Array<{
          Architecture: string;
          OS: string;
      }>
    | undefined;

property Preferences

Preferences?: Array<{ Spread: { SpreadDescriptor: string } }> | undefined;

interface PluginConfig

interface PluginConfig {}

property Args

Args: Args;

property Description

Description: string;

property Documentation

Documentation: string;

property Entrypoint

Entrypoint: string[];

property Env

Env: PluginEnv[];

property Interface

Interface: any;

property Linux

Linux: Linux;

property Mounts

Mounts: PluginMount[];

property Network

Network: Network;

property PropagatedMount

PropagatedMount: string;

property rootfs

rootfs: any;

property User

User?: User | undefined;

property WorkDir

WorkDir: string;

interface PluginDevice

interface PluginDevice {}

property Description

Description: string;

property Name

Name: string;

property Path

Path: string;

property Settable

Settable: string[];

interface PluginEnv

interface PluginEnv {}

property Description

Description: string;

property Name

Name: string;

property Settable

Settable: string[];

property Value

Value: string;

interface PluginInfo

interface PluginInfo {}

property Config

Config: PluginConfig;

property Enabled

Enabled: boolean;

property Id

Id?: string | undefined;

property Name

Name: string;

property PluginReference

PluginReference?: string | undefined;

property Settings

Settings: PluginSettings;

interface PluginInterfaceType

interface PluginInterfaceType {}

property Capability

Capability: string;

property Prefix

Prefix: string;

property Version

Version: string;

interface PluginMount

interface PluginMount {}

property Description

Description: string;

property Destination

Destination: string;

property Name

Name: string;

property Options

Options: string[];

property Settable

Settable: string[];

property Source

Source: string;

property Type

Type: string;

interface PluginSettings

interface PluginSettings {}

property Args

Args: string[];

property Devices

Devices: PluginDevice[];

property Env

Env: string[];

property Mounts

Mounts: PluginMount[];

interface PluginSpec

interface PluginSpec {}

property Disabled

Disabled?: boolean | undefined;

property Env

Env?: string[] | undefined;

property Name

Name?: string | undefined;

property Privileges

Privileges?:
    | {
          Name?: string | undefined;
          Description?: string | undefined;
          Value?: string[] | undefined;
      }
    | undefined;

property Remote

Remote?: string | undefined;

interface PluginTaskSpec

interface PluginTaskSpec extends TaskSpecBase {}

property PluginSpec

PluginSpec: PluginSpec;

property Runtime

Runtime: 'plugin';

interface Port

interface Port {}

property IP

IP: string;

property PrivatePort

PrivatePort: number;

property PublicPort

PublicPort: number;

property Type

Type: string;

interface PortBinding

interface PortBinding {}

property HostIp

HostIp?: string | undefined;

property HostPort

HostPort?: string | undefined;

interface PortConfig

interface PortConfig {}

property Name

Name?: string | undefined;

property Protocol

Protocol?: 'tcp' | 'udp' | 'sctp' | undefined;

property PublishedPort

PublishedPort?: number | undefined;

property PublishMode

PublishMode?: 'ingress' | 'host' | undefined;

property TargetPort

TargetPort?: number | undefined;

interface PortMap

interface PortMap {}

index signature

[key: string]: PortBinding[];

interface Privileges

interface Privileges {}

property CredentialSpec

CredentialSpec?:
    | {
          Config?: string | undefined;
          File?: string | undefined;
          Registry?: string | undefined;
      }
    | undefined;

property SELinuxContext

SELinuxContext?:
    | {
          Disable?: boolean | undefined;
          User?: string | undefined;
          Role?: string | undefined;
          Type?: string | undefined;
          Level?: string | undefined;
      }
    | undefined;

interface PruneContainersInfo

interface PruneContainersInfo {}

property ContainersDeleted

ContainersDeleted: string[];

property SpaceReclaimed

SpaceReclaimed: number;

interface PruneImagesInfo

interface PruneImagesInfo {}

property ImagesDeleted

ImagesDeleted: ImageRemoveInfo[];

property SpaceReclaimed

SpaceReclaimed: number;

interface PruneNetworksInfo

interface PruneNetworksInfo {}

property NetworksDeleted

NetworksDeleted: string[];

interface PruneVolumesInfo

interface PruneVolumesInfo {}

property SpaceReclaimed

SpaceReclaimed: number;

property VolumesDeleted

VolumesDeleted: string[];

interface RaftConfig

interface RaftConfig {}

property ElectionTick

ElectionTick?: number | undefined;

property HeartbeatTick

HeartbeatTick?: number | undefined;

property KeepOldSnapshots

KeepOldSnapshots?: number | undefined;

property LogEntriesForSlowFollowers

LogEntriesForSlowFollowers?: number | undefined;

property SnapshotInterval

SnapshotInterval?: number | undefined;

interface RegistryConfig

interface RegistryConfig {}

index signature

[registryAddress: string]: {
    username: string;
    password: string;
};

interface ResourceLimits

interface ResourceLimits {}

property MemoryBytes

MemoryBytes?: number | undefined;

property NanoCPUs

NanoCPUs?: number | undefined;

property Pids

Pids?: number | undefined;

interface ResourceRequirements

interface ResourceRequirements {}

property Limits

Limits?: ResourceLimits | undefined;

property Reservations

Reservations?: Resources | undefined;

interface Resources

interface Resources {}

property GenericResources

GenericResources?: GenericResource[] | undefined;

property MemoryBytes

MemoryBytes?: number | undefined;

property NanoCPUs

NanoCPUs?: number | undefined;

interface Secret

interface Secret extends Meta {}

property ID

ID: string;

property Spec

Spec?: SecretSpec | undefined;

interface SecretReference

interface SecretReference {}

property File

File?:
    | {
          Name?: string | undefined;
          UID?: string | undefined;
          GID?: string | undefined;
          Mode?: number | undefined;
      }
    | undefined;

property SecretID

SecretID?: string | undefined;

property SecretName

SecretName?: string | undefined;

interface SecretSpec

interface SecretSpec extends Annotations {}

property Data

Data?: string | undefined;

property Driver

Driver?: Driver | undefined;

property Templating

Templating?: Driver | undefined;

interface SecretVersion

interface SecretVersion {}

property Index

Index: number;

interface Service

interface Service extends Meta {}

property Endpoint

Endpoint?: Endpoint | undefined;

property ID

ID: string;

property JobStatus

JobStatus?: JobStatus | undefined;

property PreviousSpec

PreviousSpec?: ServiceSpec | undefined;

property ServiceStatus

ServiceStatus?: ServiceStatus | undefined;

property Spec

Spec?: ServiceSpec | undefined;

property UpdateStatus

UpdateStatus?: UpdateStatus | undefined;

interface ServiceListOptions

interface ServiceListOptions {}

property abortSignal

abortSignal?: AbortSignal;

property filters

filters?:
    | {
          id?: string[] | undefined;
          label?: string[] | undefined;
          mode?: Array<'replicated' | 'global'> | undefined;
          name?: string[] | undefined;
      }
    | string
    | undefined;

property status

status?: boolean | undefined;

interface ServiceMode

interface ServiceMode {}

property Global

Global?: {} | undefined;

property GlobalJob

GlobalJob?: {} | undefined;

property Replicated

Replicated?: { Replicas?: number | undefined } | undefined;

property ReplicatedJob

ReplicatedJob?:
    | {
          MaxConcurrent?: number | undefined;
          TotalCompletions?: number | undefined;
      }
    | undefined;

interface ServiceSpec

interface ServiceSpec extends Annotations {}

property EndpointSpec

EndpointSpec?: EndpointSpec | undefined;

property Mode

Mode?: ServiceMode | undefined;

property Networks

Networks?: NetworkAttachmentConfig[] | undefined;

property RollbackConfig

RollbackConfig?: UpdateConfig | undefined;

property TaskTemplate

TaskTemplate?: TaskSpec | undefined;

property UpdateConfig

UpdateConfig?: UpdateConfig | undefined;

interface ServiceStatus

interface ServiceStatus {}

property CompletedTasks

CompletedTasks: number;

property DesiredTasks

DesiredTasks: number;

property RunningTasks

RunningTasks: number;

interface Spec

interface Spec extends Annotations {}

property CAConfig

CAConfig?: CAConfig | undefined;

property Dispatcher

Dispatcher?: DispatcherConfig | undefined;

property EncryptionConfig

EncryptionConfig?: EncryptionConfig | undefined;

property Orchestration

Orchestration?: OrchestrationConfig | undefined;

property Raft

Raft: RaftConfig;

property TaskDefaults

TaskDefaults?: TaskDefaults | undefined;

interface StorageStats

interface StorageStats {}

property read_count_normalized

read_count_normalized?: number;

property read_size_bytes

read_size_bytes?: number;

property write_count_normalized

write_count_normalized?: number;

property write_size_bytes

write_size_bytes?: number;

interface Swarm

interface Swarm extends ClusterInfo {}

property JoinTokens

JoinTokens: JoinTokens;

interface TaskDefaults

interface TaskDefaults {}

property LogDriver

LogDriver?: Driver | undefined;

interface TaskRestartPolicy

interface TaskRestartPolicy {}

property Condition

Condition?: string | undefined;

property Delay

Delay?: number | undefined;

property MaxAttempts

MaxAttempts?: number | undefined;

property Window

Window?: number | undefined;

interface TaskSpecBase

interface TaskSpecBase {}

property ForceUpdate

ForceUpdate?: number | undefined;

property LogDriver

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

property Networks

Networks?: NetworkAttachmentConfig[] | undefined;

property Placement

Placement?: Placement | undefined;

property Resources

Resources?: ResourceRequirements | undefined;

property RestartPolicy

RestartPolicy?: TaskRestartPolicy | undefined;

property Runtime

Runtime?: string | undefined;

interface ThrottlingData

interface ThrottlingData {}

property periods

periods: number;

property throttled_periods

throttled_periods: number;

property throttled_time

throttled_time: number;

interface TLSInfo

interface TLSInfo {}

property CertIssuerPublicKey

CertIssuerPublicKey?: string | undefined;

property CertIssuerSubject

CertIssuerSubject?: string | undefined;

property TrustRoot

TrustRoot?: string | undefined;

interface Ulimit

interface Ulimit {}

property Hard

Hard?: number | undefined;

property Name

Name?: string | undefined;

property Soft

Soft?: number | undefined;

interface UpdateConfig

interface UpdateConfig {}

property Delay

Delay?: number | undefined;

property FailureAction

FailureAction?: string | undefined;

property MaxFailureRatio

MaxFailureRatio?: number | undefined;

property Monitor

Monitor?: number | undefined;

property Order

Order: string;

property Parallelism

Parallelism: number;

interface UpdateStatus

interface UpdateStatus {}

property CompletedAt

CompletedAt?: string | undefined;

property Message

Message?: string | undefined;

property StartedAt

StartedAt?: string | undefined;

property State

State?: UpdateState | undefined;

interface User

interface User {}

property GID

GID: number;

property UID

UID: number;

interface Version

interface Version {}

property Index

Index?: number | undefined;

interface VolumeCreateOptions

interface VolumeCreateOptions {}

property abortSignal

abortSignal?: AbortSignal;

property Driver

Driver?: string | undefined;

property DriverOpts

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

property Labels

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

property Name

Name?: string | undefined;

interface VolumeCreateResponse

interface VolumeCreateResponse {}

property CreatedAt

CreatedAt?: string | undefined;

property Driver

Driver: string;

property Labels

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

property Mountpoint

Mountpoint: string;

property Name

Name: string;

property Options

Options: { [key: string]: string };

property Scope

Scope: string;

property Status

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

property UsageData

UsageData?:
    | {
          Size: number;
          RefCount: number;
      }
    | null
    | undefined;

interface VolumeInspectInfo

interface VolumeInspectInfo {}

property Driver

Driver: string;

property Labels

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

property Mountpoint

Mountpoint: string;

property Name

Name: string;

property Options

Options: { [key: string]: string } | null;

property Scope

Scope: 'local' | 'global';

property Status

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

property UsageData

UsageData?:
    | {
          Size: number;
          RefCount: number;
      }
    | null
    | undefined;

interface VolumeListOptions

interface VolumeListOptions {}

property abortSignal

abortSignal?: AbortSignal;

property digests

digests?: boolean;

Show digest information as a RepoDigests field on each image. false

property filters

filters?: string | { [key: string]: string[] };

A JSON encoded value of the filters (a map[string][]string) to process on the volume list.

interface VolumePruneOptions

interface VolumePruneOptions {}

property abortSignal

abortSignal?: AbortSignal;

property filters

filters?: string | { [key: string]: string[] };

Filters to process on the prune list, encoded as JSON (a map[string][]string). A dictionary of key/value list is also accepted.

interface VolumeRemoveOptions

interface VolumeRemoveOptions {}

property abortSignal

abortSignal?: AbortSignal;

property force

force?: boolean | undefined;

Type Aliases

type Duration

type Duration = number;

type ExternalCAProtocol

type ExternalCAProtocol = 'cfssl' | string;

type GenericResource

type GenericResource = NamedGenericResource | DiscreteGenericResource;

type LoggingDriverType

type LoggingDriverType =
    | 'json-file'
    | 'syslog'
    | 'journald'
    | 'gelf'
    | 'fluentd'
    | 'awslogs'
    | 'splunk'
    | 'etwlogs'
    | 'none';

type MountConfig

type MountConfig = MountSettings[];

type MountConsistency

type MountConsistency = 'default' | 'consistent' | 'cached' | 'delegated';

type MountPropagation

type MountPropagation =
    | 'private'
    | 'rprivate'
    | 'shared'
    | 'rshared'
    | 'slave'
    | 'rslave';

type MountType

type MountType = 'bind' | 'volume' | 'tmpfs' | 'image';

type PluginInspectInfo

type PluginInspectInfo = PluginInfo;

type TaskSpec

type TaskSpec = ContainerTaskSpec | PluginTaskSpec | NetworkAttachmentTaskSpec;

type UpdateState

type UpdateState =
    | 'updating'
    | 'paused'
    | 'completed'
    | 'rollback_started'
    | 'rollback_paused'
    | 'rollback_completed';

Package Files (1)

index.d.ts

Dependencies (3)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/dockerode.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/dockerode)

HTML

<a href="https://www.jsdocs.io/package/@types/dockerode"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 5 days ago.
Package analyzed in 10222 ms.
Missing or incorrect documentation? Open an issue for this package.

@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