@types/dockerode

  • Version 3.3.9
  • Published
  • 67.5 kB
  • 2 dependencies
  • MIT license

Install

npm i @types/dockerode
yarn add @types/dockerode
pnpm add @types/dockerode

Overview

TypeScript definitions for dockerode

Index

Classes

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: {}, callback: Callback<NodeJS.ReadWriteStream>): void;
                        (options: {}): Promise<NodeJS.ReadWriteStream>;
                        };

                          method changes

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

                            method commit

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

                              method copy

                              copy: {
                              (options: {}, callback: Callback<any>): void;
                              (callback: Callback<any>): void;
                              (options?: {}): Promise<any>;
                              };
                              • Deprecated since RAPI v1.20

                              method exec

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

                                method export

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

                                  method getArchive

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

                                    method infoArchive

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

                                      method inspect

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

                                        method kill

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

                                          method logs

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

                                            method pause

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

                                              method putArchive

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

                                                Filename (will read synchronously), Buffer or stream

                                              method remove

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

                                                method rename

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

                                                  method resize

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

                                                    method restart

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

                                                      method start

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

                                                        method stats

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

                                                          method stop

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

                                                            method top

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

                                                              method unpause

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

                                                                method update

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

                                                                  method wait

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

                                                                    class Dockerode

                                                                    class Dockerode {}

                                                                      constructor

                                                                      constructor(options?: Dockerode.DockerOptions);

                                                                        property modem

                                                                        modem: DockerModem;

                                                                          method buildImage

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

                                                                            method checkAuth

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

                                                                              method createConfig

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

                                                                                method createContainer

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

                                                                                  method createImage

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

                                                                                    method createNetwork

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

                                                                                      method createPlugin

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

                                                                                        method createSecret

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

                                                                                          method createService

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

                                                                                            method createVolume

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

                                                                                              method df

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

                                                                                                method getConfig

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

                                                                                                  method getContainer

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

                                                                                                    method getEvents

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

                                                                                                      method getExec

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

                                                                                                        method getImage

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

                                                                                                          method getNetwork

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

                                                                                                            method getNode

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

                                                                                                              method getPlugin

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

                                                                                                                method getSecret

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

                                                                                                                  method getService

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

                                                                                                                    method getTask

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

                                                                                                                      method getVolume

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

                                                                                                                        method importImage

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

                                                                                                                          method info

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

                                                                                                                            method listConfigs

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

                                                                                                                              method listContainers

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

                                                                                                                                method listImages

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

                                                                                                                                  method listNetworks

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

                                                                                                                                    method listNodes

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

                                                                                                                                      method listPlugins

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

                                                                                                                                        method listSecrets

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

                                                                                                                                          method listServices

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

                                                                                                                                            method listTasks

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

                                                                                                                                              method listVolumes

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

                                                                                                                                                method loadImage

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

                                                                                                                                                  method ping

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

                                                                                                                                                    method pruneContainers

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

                                                                                                                                                      method pruneImages

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

                                                                                                                                                        method pruneNetworks

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

                                                                                                                                                          method pruneVolumes

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

                                                                                                                                                            method pull

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

                                                                                                                                                              method run

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

                                                                                                                                                                method searchImages

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

                                                                                                                                                                  method swarmInit

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

                                                                                                                                                                    method swarmInspect

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

                                                                                                                                                                      method swarmJoin

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

                                                                                                                                                                        method swarmLeave

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

                                                                                                                                                                          method swarmUpdate

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

                                                                                                                                                                            method version

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

                                                                                                                                                                              class Exec

                                                                                                                                                                              class Exec {}

                                                                                                                                                                                constructor

                                                                                                                                                                                constructor(modem: any, id: string);

                                                                                                                                                                                  property id

                                                                                                                                                                                  id: string;

                                                                                                                                                                                    property modem

                                                                                                                                                                                    modem: any;

                                                                                                                                                                                      method inspect

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

                                                                                                                                                                                        method resize

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

                                                                                                                                                                                          method start

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

                                                                                                                                                                                            class Image

                                                                                                                                                                                            class Image {}

                                                                                                                                                                                              constructor

                                                                                                                                                                                              constructor(modem: any, name: string);

                                                                                                                                                                                                property id

                                                                                                                                                                                                id: string;

                                                                                                                                                                                                  property modem

                                                                                                                                                                                                  modem: any;

                                                                                                                                                                                                    method distribution

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

                                                                                                                                                                                                      method get

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

                                                                                                                                                                                                        method history

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

                                                                                                                                                                                                          method inspect

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

                                                                                                                                                                                                            method push

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

                                                                                                                                                                                                              method remove

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

                                                                                                                                                                                                                method tag

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

                                                                                                                                                                                                                  class Network

                                                                                                                                                                                                                  class Network {}

                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                    constructor(modem: any, id: string);

                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                        property modem

                                                                                                                                                                                                                        modem: any;

                                                                                                                                                                                                                          method connect

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

                                                                                                                                                                                                                            method disconnect

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

                                                                                                                                                                                                                              method inspect

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

                                                                                                                                                                                                                                method remove

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

                                                                                                                                                                                                                                  class Node

                                                                                                                                                                                                                                  class Node {}

                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                    constructor(modem: any, id: string);

                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                        property modem

                                                                                                                                                                                                                                        modem: any;

                                                                                                                                                                                                                                          method inspect

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

                                                                                                                                                                                                                                            method remove

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

                                                                                                                                                                                                                                              method update

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

                                                                                                                                                                                                                                                class Plugin

                                                                                                                                                                                                                                                class Plugin {}

                                                                                                                                                                                                                                                  constructor

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

                                                                                                                                                                                                                                                    property modem

                                                                                                                                                                                                                                                    modem: any;

                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                        property remote

                                                                                                                                                                                                                                                        remote: any;

                                                                                                                                                                                                                                                          method configure

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

                                                                                                                                                                                                                                                            method disable

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

                                                                                                                                                                                                                                                              method enable

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

                                                                                                                                                                                                                                                                method inspect

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

                                                                                                                                                                                                                                                                  method privileges

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

                                                                                                                                                                                                                                                                    method pull

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

                                                                                                                                                                                                                                                                      method push

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

                                                                                                                                                                                                                                                                        method remove

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

                                                                                                                                                                                                                                                                          method upgrade

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

                                                                                                                                                                                                                                                                            class Secret

                                                                                                                                                                                                                                                                            class Secret {}

                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                              constructor(modem: any, id: string);

                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                id: string;

                                                                                                                                                                                                                                                                                  property modem

                                                                                                                                                                                                                                                                                  modem: any;

                                                                                                                                                                                                                                                                                    method inspect

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

                                                                                                                                                                                                                                                                                      method remove

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

                                                                                                                                                                                                                                                                                        method update

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

                                                                                                                                                                                                                                                                                          class Service

                                                                                                                                                                                                                                                                                          class Service {}

                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                            constructor(modem: any, id: string);

                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                                                                                                property modem

                                                                                                                                                                                                                                                                                                modem: any;

                                                                                                                                                                                                                                                                                                  method inspect

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

                                                                                                                                                                                                                                                                                                    method logs

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

                                                                                                                                                                                                                                                                                                      method remove

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

                                                                                                                                                                                                                                                                                                        method update

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

                                                                                                                                                                                                                                                                                                          class Task

                                                                                                                                                                                                                                                                                                          class Task {}

                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                            constructor(modem: any, id: string);

                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                                                                                                                property modem

                                                                                                                                                                                                                                                                                                                modem: any;

                                                                                                                                                                                                                                                                                                                  method inspect

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

                                                                                                                                                                                                                                                                                                                    class Volume

                                                                                                                                                                                                                                                                                                                    class Volume {}

                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                      constructor(modem: any, name: string);

                                                                                                                                                                                                                                                                                                                        property modem

                                                                                                                                                                                                                                                                                                                        modem: any;

                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                            method inspect

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

                                                                                                                                                                                                                                                                                                                              method remove

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

                                                                                                                                                                                                                                                                                                                                Interfaces

                                                                                                                                                                                                                                                                                                                                interface Annotations

                                                                                                                                                                                                                                                                                                                                interface Annotations {}

                                                                                                                                                                                                                                                                                                                                  property Labels

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

                                                                                                                                                                                                                                                                                                                                    property Name

                                                                                                                                                                                                                                                                                                                                    Name?: string | undefined;

                                                                                                                                                                                                                                                                                                                                      interface Args

                                                                                                                                                                                                                                                                                                                                      interface Args {}

                                                                                                                                                                                                                                                                                                                                        property Description

                                                                                                                                                                                                                                                                                                                                        Description: string;

                                                                                                                                                                                                                                                                                                                                          property Name

                                                                                                                                                                                                                                                                                                                                          Name: string;

                                                                                                                                                                                                                                                                                                                                            property Settable

                                                                                                                                                                                                                                                                                                                                            Settable: string[];

                                                                                                                                                                                                                                                                                                                                              property Value

                                                                                                                                                                                                                                                                                                                                              Value: string;

                                                                                                                                                                                                                                                                                                                                                interface AuthConfig

                                                                                                                                                                                                                                                                                                                                                interface AuthConfig {}

                                                                                                                                                                                                                                                                                                                                                  property email

                                                                                                                                                                                                                                                                                                                                                  email?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                    property password

                                                                                                                                                                                                                                                                                                                                                    password: string;

                                                                                                                                                                                                                                                                                                                                                      property serveraddress

                                                                                                                                                                                                                                                                                                                                                      serveraddress: string;

                                                                                                                                                                                                                                                                                                                                                        property username

                                                                                                                                                                                                                                                                                                                                                        username: string;

                                                                                                                                                                                                                                                                                                                                                          interface BlkioStatEntry

                                                                                                                                                                                                                                                                                                                                                          interface BlkioStatEntry {}

                                                                                                                                                                                                                                                                                                                                                            property major

                                                                                                                                                                                                                                                                                                                                                            major: number;

                                                                                                                                                                                                                                                                                                                                                              property minor

                                                                                                                                                                                                                                                                                                                                                              minor: number;

                                                                                                                                                                                                                                                                                                                                                                property op

                                                                                                                                                                                                                                                                                                                                                                op: string;

                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                  value: number;

                                                                                                                                                                                                                                                                                                                                                                    interface BlkioStats

                                                                                                                                                                                                                                                                                                                                                                    interface BlkioStats {}

                                                                                                                                                                                                                                                                                                                                                                      property io_merged_recursive

                                                                                                                                                                                                                                                                                                                                                                      io_merged_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                        property io_queue_recursive

                                                                                                                                                                                                                                                                                                                                                                        io_queue_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                          property io_service_bytes_recursive

                                                                                                                                                                                                                                                                                                                                                                          io_service_bytes_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                            property io_service_time_recursive

                                                                                                                                                                                                                                                                                                                                                                            io_service_time_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                              property io_serviced_recursive

                                                                                                                                                                                                                                                                                                                                                                              io_serviced_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                                property io_time_recursive

                                                                                                                                                                                                                                                                                                                                                                                io_time_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                                  property io_wait_time_recursive

                                                                                                                                                                                                                                                                                                                                                                                  io_wait_time_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                                    property sectors_recursive

                                                                                                                                                                                                                                                                                                                                                                                    sectors_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                                      interface CAConfig

                                                                                                                                                                                                                                                                                                                                                                                      interface CAConfig {}

                                                                                                                                                                                                                                                                                                                                                                                        property ExternalCAs

                                                                                                                                                                                                                                                                                                                                                                                        ExternalCAs?: ExternalCA[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                          property ForceRotate

                                                                                                                                                                                                                                                                                                                                                                                          ForceRotate?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                            property NodeCertExpiry

                                                                                                                                                                                                                                                                                                                                                                                            NodeCertExpiry?: Duration | undefined;

                                                                                                                                                                                                                                                                                                                                                                                              property SigningCACert

                                                                                                                                                                                                                                                                                                                                                                                              SigningCACert?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                property SigningCAKey

                                                                                                                                                                                                                                                                                                                                                                                                SigningCAKey?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                  interface ClusterInfo

                                                                                                                                                                                                                                                                                                                                                                                                  interface ClusterInfo extends Meta {}

                                                                                                                                                                                                                                                                                                                                                                                                    property DataPathPort

                                                                                                                                                                                                                                                                                                                                                                                                    DataPathPort: number;

                                                                                                                                                                                                                                                                                                                                                                                                      property DefaultAddrPool

                                                                                                                                                                                                                                                                                                                                                                                                      DefaultAddrPool: string[];

                                                                                                                                                                                                                                                                                                                                                                                                        property ID

                                                                                                                                                                                                                                                                                                                                                                                                        ID: string;

                                                                                                                                                                                                                                                                                                                                                                                                          property RootRotationInProgress

                                                                                                                                                                                                                                                                                                                                                                                                          RootRotationInProgress: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                            property Spec

                                                                                                                                                                                                                                                                                                                                                                                                            Spec: Spec;

                                                                                                                                                                                                                                                                                                                                                                                                              property SubnetSize

                                                                                                                                                                                                                                                                                                                                                                                                              SubnetSize: number;

                                                                                                                                                                                                                                                                                                                                                                                                                property TLSInfo

                                                                                                                                                                                                                                                                                                                                                                                                                TLSInfo: TLSInfo;

                                                                                                                                                                                                                                                                                                                                                                                                                  interface ConfigInfo

                                                                                                                                                                                                                                                                                                                                                                                                                  interface ConfigInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property CreatedAt

                                                                                                                                                                                                                                                                                                                                                                                                                    CreatedAt: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property ID

                                                                                                                                                                                                                                                                                                                                                                                                                      ID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                        property Spec

                                                                                                                                                                                                                                                                                                                                                                                                                        Spec?: ConfigSpec | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                          property UpdatedAt

                                                                                                                                                                                                                                                                                                                                                                                                                          UpdatedAt?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                            property Version

                                                                                                                                                                                                                                                                                                                                                                                                                            Version: SecretVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                              interface ConfigSpec

                                                                                                                                                                                                                                                                                                                                                                                                                              interface ConfigSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property Data

                                                                                                                                                                                                                                                                                                                                                                                                                                Data: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property Labels

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

                                                                                                                                                                                                                                                                                                                                                                                                                                    property Name

                                                                                                                                                                                                                                                                                                                                                                                                                                    Name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConfigVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConfigVersion {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        property Index

                                                                                                                                                                                                                                                                                                                                                                                                                                        Index: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ContainerCreateOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ContainerCreateOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                            abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property AttachStderr

                                                                                                                                                                                                                                                                                                                                                                                                                                              AttachStderr?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property AttachStdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                AttachStdin?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property AttachStdout

                                                                                                                                                                                                                                                                                                                                                                                                                                                  AttachStdout?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Cmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cmd?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Domainname

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Domainname?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Entrypoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Entrypoint?: string | string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Env

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Env?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ExposedPorts

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Healthcheck

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Healthcheck?: HealthConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property HostConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                HostConfig?: HostConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Hostname

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Hostname?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Image

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Image?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Labels

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property MacAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MacAddress?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property NetworkDisabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NetworkDisabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property NetworkingConfig

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property OpenStdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                OpenStdin?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property StdinOnce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  StdinOnce?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property StopSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    StopSignal?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property StopTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      StopTimeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Tty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tty?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          User?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Volumes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property WorkingDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WorkingDir?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ContainerInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ContainerInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Command

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Command: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Created: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property HostConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HostConfig: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NetworkMode: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Image

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Image: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ImageID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ImageID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Labels

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Mounts

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Names: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property NetworkSettings

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Ports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ports: Port[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property State

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        State: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Status: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ContainerInspectInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ContainerInspectInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property AppArmorProfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AppArmorProfile: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Args: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Config

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Created: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Driver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Driver: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ExecIDs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ExecIDs?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property GraphDriver

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property HostConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HostConfig: HostConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property HostnamePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              HostnamePath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property HostsPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HostsPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Image

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Image: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property LogPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      LogPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property MountLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MountLabel: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Mounts

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property NetworkSettings

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Platform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Platform: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ProcessLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ProcessLabel: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ResolvConfPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ResolvConfPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property RestartCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RestartCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property State

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ContainerLogsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ContainerLogsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property details

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                details?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property follow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  follow?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property since

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    since?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property stderr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stderr?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property stdout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stdout?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tail?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property timestamps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            timestamps?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ContainerRemoveOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ContainerRemoveOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property force

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                force?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  link?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property v

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Args?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property CapabilityAdd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CapabilityAdd?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property CapabilityDrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CapabilityDrop?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Command

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Command?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Dir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dir?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property DNSConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DNSConfig?: DNSConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Env?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Groups

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Groups?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property HealthCheck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        HealthCheck?: HealthConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Hostname

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Hostname?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Hosts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Hosts?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Image

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Image?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Init?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Isolation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Isolation?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Labels

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Mounts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Mounts?: MountSettings[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property OpenStdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OpenStdin?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Privileges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Privileges?: Privileges | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ReadOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ReadOnly?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Secrets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Secrets?: SecretReference[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property StopGracePeriod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                StopGracePeriod?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property StopSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  StopSignal?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Sysctls

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property TTY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TTY?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Ulimits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Ulimits?: Ulimit[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          User?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ContainerStats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ContainerStats {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property blkio_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              blkio_stats?: BlkioStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cpu_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cpu_stats: CPUStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property memory_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  memory_stats: MemoryStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property networks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    networks: NetworkStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property num_procs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      num_procs: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property pid_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pid_stats?: PidsStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property precpu_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          precpu_stats: CPUStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property preread

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            preread: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              read: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property storage_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                storage_stats?: StorageStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ContainerTaskSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ContainerTaskSpec extends TaskSpecBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ContainerSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ContainerSpec?: ContainerSpec | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerWaitOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerWaitOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property condition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          condition?: 'not-running' | 'next-exit' | 'removed' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Since v1.30

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CPUStats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CPUStats {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cpu_usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cpu_usage: CPUUsage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property online_cpus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              online_cpus: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property system_cpu_usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                system_cpu_usage: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property throttling_data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  throttling_data: ThrottlingData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CPUUsage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CPUUsage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property percpu_usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      percpu_usage: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property total_usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        total_usage: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property usage_in_kernelmode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          usage_in_kernelmode: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property usage_in_usermode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            usage_in_usermode: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CreateServiceOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CreateServiceOptions extends ServiceSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property authconfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  authconfig?: AuthConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DeviceMapping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DeviceMapping {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property CgroupPermissions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CgroupPermissions: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property PathInContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        PathInContainer: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property PathOnHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          PathOnHost: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DeviceRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DeviceRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Capabilities?: string[][] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Count?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property DeviceIDs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DeviceIDs?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Driver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Driver?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Options

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DiscreteGenericResource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DiscreteGenericResource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Kind?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Value?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DispatcherConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DispatcherConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property HeartbeatPeriod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HeartbeatPeriod?: Duration | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DNSConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DNSConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Nameservers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nameservers?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Options?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Search?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DockerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DockerOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ca

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cert

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                host?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property key

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    port?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Promise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Promise?: typeof Promise | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property protocol

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property socketPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          socketPath?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property sshAuthAgent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sshAuthAgent?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              timeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property username

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                username?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  version?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DockerVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DockerVersion {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ApiVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ApiVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Arch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Arch: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property BuildTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BuildTime: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Components

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property GitCommit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GitCommit: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property GoVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GoVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property KernelVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  KernelVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property MinAPIVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MinAPIVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Os

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Os: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Platform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Platform: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Driver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Driver {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Options

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EncryptionConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EncryptionConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property AutoLockManagers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AutoLockManagers: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Endpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Endpoint {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Ports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Ports?: PortConfig[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Spec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Spec?: EndpointSpec | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property VirtualIPs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            VirtualIPs?: EndpointVirtualIP[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EndpointsConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EndpointsConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: EndpointSettings;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EndpointSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EndpointSettings {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Aliases?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property DriverOpts

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property EndpointID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        EndpointID?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Gateway

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Gateway?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property GlobalIPv6Address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GlobalIPv6Address?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property GlobalIPV6PrefixLen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GlobalIPV6PrefixLen?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property IPAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                IPAddress?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property IPAMConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IPAMConfig?: IPAMConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property IPPrefixLen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IPPrefixLen?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property IPv6Gateway

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      IPv6Gateway?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Links?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property MacAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MacAddress?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property NetworkID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NetworkID?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EndpointSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EndpointSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Mode?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Ports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Ports?: PortConfig[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EndpointVirtualIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EndpointVirtualIP {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Addr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Addr?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property NetworkID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NetworkID?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ExecCreateOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ExecCreateOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property AttachStderr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AttachStderr?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property AttachStdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                AttachStdin?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property AttachStdout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AttachStdout?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Cmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cmd?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property DetachKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DetachKeys?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Env?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Privileged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Privileged?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Tty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tty?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              User?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property WorkingDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WorkingDir?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ExecInspectInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ExecInspectInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property CanRemove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CanRemove: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ContainerID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ContainerID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property DetachKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DetachKeys: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ExitCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ExitCode: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property OpenStderr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              OpenStderr: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property OpenStdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                OpenStdin: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property OpenStdout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OpenStdout: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Pid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pid: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ProcessConfig

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Running

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Running: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ExecStartOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ExecStartOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Detach

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Detach?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property hijack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hijack?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property stdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stdin?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Tty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tty?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ExternalCA

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ExternalCA {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property CACert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CACert: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Options

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Protocol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Protocol: ExternalCAProtocol;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property URL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              URL: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetEventsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GetEventsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property filters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filters?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    config?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    container?: string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    daemon?: string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    event?: string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    image?: string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    label?: string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    network?: