@types/dockerode

  • Version 3.3.18
  • Published
  • 70.4 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

Interfaces

Type Aliases

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: {}, 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 & { 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: {}, 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: 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: {
                                                                                                                                                                                                          (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: 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: {}, 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 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 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 OpenStdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OpenStdin?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property platform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    platform?: 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<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 | 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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 ContainerStartOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ContainerStartOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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