@types/dockerode

  • Version 3.3.29
  • Published
  • 73.1 kB
  • 3 dependencies
  • MIT license

Install

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

Overview

TypeScript definitions for dockerode

Index

Classes

Interfaces

Type Aliases

Classes

class Config

class Config {}

    constructor

    constructor(modem: any, id: string);

      property id

      id: string;

        property modem

        modem: any;

          method inspect

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

            method remove

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

              method update

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

                class Container

                class Container {}

                  constructor

                  constructor(modem: any, id: string);

                    property id

                    id: string;

                      property modem

                      modem: any;

                        method attach

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

                          method changes

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

                            method commit

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

                              method copy

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

                              method exec

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

                                method export

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

                                  method getArchive

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

                                    method infoArchive

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

                                      method inspect

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

                                        method kill

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

                                          method logs

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

                                            method pause

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

                                              method putArchive

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

                                                Filename (will read synchronously), Buffer or stream

                                              method remove

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

                                                method rename

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

                                                  method resize

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

                                                    method restart

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

                                                      method start

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

                                                        method stats

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

                                                          method stop

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

                                                            method top

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

                                                              method unpause

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

                                                                method update

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

                                                                  method wait

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

                                                                    class Dockerode

                                                                    class Dockerode {}

                                                                      constructor

                                                                      constructor(options?: Dockerode.DockerOptions);

                                                                        property modem

                                                                        modem: DockerModem;

                                                                          method buildImage

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

                                                                            method checkAuth

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

                                                                              method createConfig

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

                                                                                method createContainer

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

                                                                                  method createImage

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

                                                                                    method createNetwork

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

                                                                                      method createPlugin

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

                                                                                        method createSecret

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

                                                                                          method createService

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

                                                                                            method createVolume

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

                                                                                              method df

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

                                                                                                method getConfig

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

                                                                                                  method getContainer

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

                                                                                                    method getEvents

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

                                                                                                      method getExec

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

                                                                                                        method getImage

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

                                                                                                          method getNetwork

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

                                                                                                            method getNode

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

                                                                                                              method getPlugin

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

                                                                                                                method getSecret

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

                                                                                                                  method getService

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

                                                                                                                    method getTask

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

                                                                                                                      method getVolume

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

                                                                                                                        method importImage

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

                                                                                                                          method info

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

                                                                                                                            method listConfigs

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

                                                                                                                              method listContainers

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

                                                                                                                                method listImages

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

                                                                                                                                  method listNetworks

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

                                                                                                                                    method listNodes

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

                                                                                                                                      method listPlugins

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

                                                                                                                                        method listSecrets

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

                                                                                                                                          method listServices

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

                                                                                                                                            method listTasks

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

                                                                                                                                              method listVolumes

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

                                                                                                                                                method loadImage

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

                                                                                                                                                  method ping

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

                                                                                                                                                    method pruneContainers

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

                                                                                                                                                      method pruneImages

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

                                                                                                                                                        method pruneNetworks

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

                                                                                                                                                          method pruneVolumes

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

                                                                                                                                                            method pull

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

                                                                                                                                                              method run

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

                                                                                                                                                                method searchImages

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

                                                                                                                                                                  method swarmInit

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

                                                                                                                                                                    method swarmInspect

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

                                                                                                                                                                      method swarmJoin

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

                                                                                                                                                                        method swarmLeave

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

                                                                                                                                                                          method swarmUpdate

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

                                                                                                                                                                            method version

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

                                                                                                                                                                              class Exec

                                                                                                                                                                              class Exec {}

                                                                                                                                                                                constructor

                                                                                                                                                                                constructor(modem: any, id: string);

                                                                                                                                                                                  property id

                                                                                                                                                                                  id: string;

                                                                                                                                                                                    property modem

                                                                                                                                                                                    modem: any;

                                                                                                                                                                                      method inspect

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

                                                                                                                                                                                        method resize

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

                                                                                                                                                                                          method start

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

                                                                                                                                                                                            class Image

                                                                                                                                                                                            class Image {}

                                                                                                                                                                                              constructor

                                                                                                                                                                                              constructor(modem: any, name: string);

                                                                                                                                                                                                property id

                                                                                                                                                                                                id: string;

                                                                                                                                                                                                  property modem

                                                                                                                                                                                                  modem: any;

                                                                                                                                                                                                    method distribution

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

                                                                                                                                                                                                      method get

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

                                                                                                                                                                                                        method history

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

                                                                                                                                                                                                          method inspect

                                                                                                                                                                                                          inspect: {
                                                                                                                                                                                                          (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: ImageTagOptions, callback: Callback<any>): void;
                                                                                                                                                                                                                (callback: Callback<any>): void;
                                                                                                                                                                                                                (options?: ImageTagOptions): Promise<any>;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  class Network

                                                                                                                                                                                                                  class Network {}

                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                    constructor(modem: any, id: string);

                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                        property modem

                                                                                                                                                                                                                        modem: any;

                                                                                                                                                                                                                          method connect

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

                                                                                                                                                                                                                            method disconnect

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

                                                                                                                                                                                                                              method inspect

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

                                                                                                                                                                                                                                method remove

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

                                                                                                                                                                                                                                  class Node

                                                                                                                                                                                                                                  class Node {}

                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                    constructor(modem: any, id: string);

                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                        property modem

                                                                                                                                                                                                                                        modem: any;

                                                                                                                                                                                                                                          method inspect

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

                                                                                                                                                                                                                                            method remove

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

                                                                                                                                                                                                                                              method update

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

                                                                                                                                                                                                                                                class Plugin

                                                                                                                                                                                                                                                class Plugin {}

                                                                                                                                                                                                                                                  constructor

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

                                                                                                                                                                                                                                                    property modem

                                                                                                                                                                                                                                                    modem: any;

                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                        property remote

                                                                                                                                                                                                                                                        remote: any;

                                                                                                                                                                                                                                                          method configure

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

                                                                                                                                                                                                                                                            method disable

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

                                                                                                                                                                                                                                                              method enable

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

                                                                                                                                                                                                                                                                method inspect

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

                                                                                                                                                                                                                                                                  method privileges

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

                                                                                                                                                                                                                                                                    method pull

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

                                                                                                                                                                                                                                                                      method push

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

                                                                                                                                                                                                                                                                        method remove

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

                                                                                                                                                                                                                                                                          method upgrade

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

                                                                                                                                                                                                                                                                            class Secret

                                                                                                                                                                                                                                                                            class Secret {}

                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                              constructor(modem: any, id: string);

                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                id: string;

                                                                                                                                                                                                                                                                                  property modem

                                                                                                                                                                                                                                                                                  modem: any;

                                                                                                                                                                                                                                                                                    method inspect

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

                                                                                                                                                                                                                                                                                      method remove

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

                                                                                                                                                                                                                                                                                        method update

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

                                                                                                                                                                                                                                                                                          class Service

                                                                                                                                                                                                                                                                                          class Service {}

                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                            constructor(modem: any, id: string);

                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                                                                                                property modem

                                                                                                                                                                                                                                                                                                modem: any;

                                                                                                                                                                                                                                                                                                  method inspect

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

                                                                                                                                                                                                                                                                                                    method logs

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

                                                                                                                                                                                                                                                                                                      method remove

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

                                                                                                                                                                                                                                                                                                        method update

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

                                                                                                                                                                                                                                                                                                          class Task

                                                                                                                                                                                                                                                                                                          class Task {}

                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                            constructor(modem: any, id: string);

                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                                                                                                                property modem

                                                                                                                                                                                                                                                                                                                modem: any;

                                                                                                                                                                                                                                                                                                                  method inspect

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

                                                                                                                                                                                                                                                                                                                    class Volume

                                                                                                                                                                                                                                                                                                                    class Volume {}

                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                      constructor(modem: any, name: string);

                                                                                                                                                                                                                                                                                                                        property modem

                                                                                                                                                                                                                                                                                                                        modem: any;

                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                            method inspect

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

                                                                                                                                                                                                                                                                                                                              method remove

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

                                                                                                                                                                                                                                                                                                                                Interfaces

                                                                                                                                                                                                                                                                                                                                interface Annotations

                                                                                                                                                                                                                                                                                                                                interface Annotations {}

                                                                                                                                                                                                                                                                                                                                  property Labels

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

                                                                                                                                                                                                                                                                                                                                    property Name

                                                                                                                                                                                                                                                                                                                                    Name?: string | undefined;

                                                                                                                                                                                                                                                                                                                                      interface Args

                                                                                                                                                                                                                                                                                                                                      interface Args {}

                                                                                                                                                                                                                                                                                                                                        property Description

                                                                                                                                                                                                                                                                                                                                        Description: string;

                                                                                                                                                                                                                                                                                                                                          property Name

                                                                                                                                                                                                                                                                                                                                          Name: string;

                                                                                                                                                                                                                                                                                                                                            property Settable

                                                                                                                                                                                                                                                                                                                                            Settable: string[];

                                                                                                                                                                                                                                                                                                                                              property Value

                                                                                                                                                                                                                                                                                                                                              Value: string;

                                                                                                                                                                                                                                                                                                                                                interface AuthConfig

                                                                                                                                                                                                                                                                                                                                                interface AuthConfig {}

                                                                                                                                                                                                                                                                                                                                                  property auth

                                                                                                                                                                                                                                                                                                                                                  auth?: string;

                                                                                                                                                                                                                                                                                                                                                    property email

                                                                                                                                                                                                                                                                                                                                                    email?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                    property identitytoken

                                                                                                                                                                                                                                                                                                                                                    identitytoken?: string;

                                                                                                                                                                                                                                                                                                                                                      property password

                                                                                                                                                                                                                                                                                                                                                      password?: string;

                                                                                                                                                                                                                                                                                                                                                        property registrytoken

                                                                                                                                                                                                                                                                                                                                                        registrytoken?: string;

                                                                                                                                                                                                                                                                                                                                                          property serveraddress

                                                                                                                                                                                                                                                                                                                                                          serveraddress?: string;

                                                                                                                                                                                                                                                                                                                                                            property username

                                                                                                                                                                                                                                                                                                                                                            username?: string;

                                                                                                                                                                                                                                                                                                                                                              interface BlkioStatEntry

                                                                                                                                                                                                                                                                                                                                                              interface BlkioStatEntry {}

                                                                                                                                                                                                                                                                                                                                                                property major

                                                                                                                                                                                                                                                                                                                                                                major: number;

                                                                                                                                                                                                                                                                                                                                                                  property minor

                                                                                                                                                                                                                                                                                                                                                                  minor: number;

                                                                                                                                                                                                                                                                                                                                                                    property op

                                                                                                                                                                                                                                                                                                                                                                    op: string;

                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                      value: number;

                                                                                                                                                                                                                                                                                                                                                                        interface BlkioStats

                                                                                                                                                                                                                                                                                                                                                                        interface BlkioStats {}

                                                                                                                                                                                                                                                                                                                                                                          property io_merged_recursive

                                                                                                                                                                                                                                                                                                                                                                          io_merged_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                            property io_queue_recursive

                                                                                                                                                                                                                                                                                                                                                                            io_queue_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                              property io_service_bytes_recursive

                                                                                                                                                                                                                                                                                                                                                                              io_service_bytes_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                                property io_service_time_recursive

                                                                                                                                                                                                                                                                                                                                                                                io_service_time_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                                  property io_serviced_recursive

                                                                                                                                                                                                                                                                                                                                                                                  io_serviced_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                                    property io_time_recursive

                                                                                                                                                                                                                                                                                                                                                                                    io_time_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                                      property io_wait_time_recursive

                                                                                                                                                                                                                                                                                                                                                                                      io_wait_time_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                                        property sectors_recursive

                                                                                                                                                                                                                                                                                                                                                                                        sectors_recursive: BlkioStatEntry[];

                                                                                                                                                                                                                                                                                                                                                                                          interface CAConfig

                                                                                                                                                                                                                                                                                                                                                                                          interface CAConfig {}

                                                                                                                                                                                                                                                                                                                                                                                            property ExternalCAs

                                                                                                                                                                                                                                                                                                                                                                                            ExternalCAs?: ExternalCA[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                              property ForceRotate

                                                                                                                                                                                                                                                                                                                                                                                              ForceRotate?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                property NodeCertExpiry

                                                                                                                                                                                                                                                                                                                                                                                                NodeCertExpiry?: Duration | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                  property SigningCACert

                                                                                                                                                                                                                                                                                                                                                                                                  SigningCACert?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                    property SigningCAKey

                                                                                                                                                                                                                                                                                                                                                                                                    SigningCAKey?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                      interface ClusterInfo

                                                                                                                                                                                                                                                                                                                                                                                                      interface ClusterInfo extends Meta {}

                                                                                                                                                                                                                                                                                                                                                                                                        property DataPathPort

                                                                                                                                                                                                                                                                                                                                                                                                        DataPathPort: number;

                                                                                                                                                                                                                                                                                                                                                                                                          property DefaultAddrPool

                                                                                                                                                                                                                                                                                                                                                                                                          DefaultAddrPool: string[];

                                                                                                                                                                                                                                                                                                                                                                                                            property ID

                                                                                                                                                                                                                                                                                                                                                                                                            ID: string;

                                                                                                                                                                                                                                                                                                                                                                                                              property RootRotationInProgress

                                                                                                                                                                                                                                                                                                                                                                                                              RootRotationInProgress: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                property Spec

                                                                                                                                                                                                                                                                                                                                                                                                                Spec: Spec;

                                                                                                                                                                                                                                                                                                                                                                                                                  property SubnetSize

                                                                                                                                                                                                                                                                                                                                                                                                                  SubnetSize: number;

                                                                                                                                                                                                                                                                                                                                                                                                                    property TLSInfo

                                                                                                                                                                                                                                                                                                                                                                                                                    TLSInfo: TLSInfo;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConfigInfo

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConfigInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property CreatedAt

                                                                                                                                                                                                                                                                                                                                                                                                                        CreatedAt: string;

                                                                                                                                                                                                                                                                                                                                                                                                                          property ID

                                                                                                                                                                                                                                                                                                                                                                                                                          ID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            property Spec

                                                                                                                                                                                                                                                                                                                                                                                                                            Spec?: ConfigSpec | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                              property UpdatedAt

                                                                                                                                                                                                                                                                                                                                                                                                                              UpdatedAt?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                property Version

                                                                                                                                                                                                                                                                                                                                                                                                                                Version: SecretVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ConfigReference

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ConfigReference {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property ConfigID

                                                                                                                                                                                                                                                                                                                                                                                                                                    ConfigID?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property ConfigName

                                                                                                                                                                                                                                                                                                                                                                                                                                      ConfigName?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property File

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

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ConfigSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ConfigSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            property Data

                                                                                                                                                                                                                                                                                                                                                                                                                                            Data: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property Labels

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                property Name

                                                                                                                                                                                                                                                                                                                                                                                                                                                Name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ConfigVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ConfigVersion {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Index

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Index: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerAttachOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerAttachOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                        abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property detachKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                          detachKeys?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property hijack

                                                                                                                                                                                                                                                                                                                                                                                                                                                            hijack?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property logs

                                                                                                                                                                                                                                                                                                                                                                                                                                                              logs?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property stderr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                stderr?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property stdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stdin?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stdout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stdout?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property stream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stream?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ContainerCreateOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ContainerCreateOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ArgsEscaped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ArgsEscaped?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property AttachStderr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AttachStderr?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property AttachStdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                AttachStdin?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property AttachStdout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  AttachStdout?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Cmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Cmd?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Domainname

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Domainname?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Entrypoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Entrypoint?: string | string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Env?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ExposedPorts

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Healthcheck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Healthcheck?: HealthConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property HostConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HostConfig?: HostConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Hostname

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Hostname?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Image

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Image?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Labels

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property MacAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MacAddress?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property NetworkDisabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NetworkDisabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property NetworkingConfig

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property OnBuild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                OnBuild?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property OpenStdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OpenStdin?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property platform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    platform?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Shell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Shell?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property StdinOnce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        StdinOnce?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property StopSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          StopSignal?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property StopTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            StopTimeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Tty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tty?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                User?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Volumes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property WorkingDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WorkingDir?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Command

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Command: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Created: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property HostConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HostConfig: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NetworkMode: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Image

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Image: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ImageID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ImageID: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Labels

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Mounts

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Names: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property NetworkSettings

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Ports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Ports: Port[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property State

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              State: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Status: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ContainerInspectInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ContainerInspectInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property AppArmorProfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AppArmorProfile: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Args: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Config

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Created: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Driver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Driver: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ExecIDs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ExecIDs?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property GraphDriver

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property HostConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  HostConfig: HostConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property HostnamePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    HostnamePath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property HostsPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HostsPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Image

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Image: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property LogPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LogPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property MountLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MountLabel: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Mounts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Mounts: Array<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 ContainerInspectOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ContainerInspectOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerListOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerListOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          all?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Return all containers. By default, only running containers are shown false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property filters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filters?: string | { [key: string]: string[] };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Filters to process on the container list, encoded as JSON (a map[string][]string). A dictionary of key/value list is also accepted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property limit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          limit?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Return this number of most recently created containers, including non-running ones.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          size?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Return the size of container as fields SizeRw and SizeRootFs. false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ContainerLogsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ContainerLogsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property details

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              details?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property follow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                follow?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property since

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  since?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stderr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stderr?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property stdout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stdout?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tail?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property timestamps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          timestamps?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property until

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            until?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ContainerRemoveOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ContainerRemoveOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property force

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property v

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ContainerSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Args?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property CapabilityAdd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CapabilityAdd?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property CapabilityDrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CapabilityDrop?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Command

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Command?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Configs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Configs?: ConfigReference[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Dir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dir?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property DNSConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DNSConfig?: DNSConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Env?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Groups

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Groups?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property HealthCheck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          HealthCheck?: HealthConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Hostname

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Hostname?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Hosts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Hosts?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Image

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Image?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Init?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Isolation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Isolation?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Labels

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Mounts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Mounts?: MountSettings[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property OpenStdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          OpenStdin?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Privileges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Privileges?: Privileges | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ReadOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ReadOnly?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Secrets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Secrets?: SecretReference[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property StopGracePeriod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  StopGracePeriod?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property StopSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    StopSignal?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Sysctls

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property TTY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TTY?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Ulimits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Ulimits?: Ulimit[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            User?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ContainerStartOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ContainerStartOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property detachKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  detachKeys?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ContainerStats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ContainerStats {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property blkio_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      blkio_stats?: BlkioStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cpu_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cpu_stats: CPUStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property memory_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          memory_stats: MemoryStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property networks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            networks: NetworkStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property num_procs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              num_procs: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property pids_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pids_stats?: PidsStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property precpu_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  precpu_stats: CPUStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property preread

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preread: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      read: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property storage_stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        storage_stats?: StorageStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ContainerStopOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ContainerStopOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property signal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              signal?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property t

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Number of seconds to wait before killing the container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ContainerTaskSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ContainerTaskSpec extends TaskSpecBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ContainerSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ContainerSpec?: ContainerSpec | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ContainerWaitOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ContainerWaitOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property condition

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CPUStats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CPUStats {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property cpu_usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cpu_usage: CPUUsage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property online_cpus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            online_cpus: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property system_cpu_usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              system_cpu_usage: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property throttling_data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                throttling_data: ThrottlingData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CPUUsage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CPUUsage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property percpu_usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    percpu_usage: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property total_usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      total_usage: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property usage_in_kernelmode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        usage_in_kernelmode: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property usage_in_usermode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          usage_in_usermode: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CreateServiceOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CreateServiceOptions extends ServiceSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property abortSignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abortSignal?: AbortSignal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property authconfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                authconfig?: AuthConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DeviceMapping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DeviceMapping {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property CgroupPermissions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CgroupPermissions: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property PathInContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PathInContainer: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property PathOnHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        PathOnHost: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DeviceRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DeviceRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Capabilities?: string[][] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Count?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property DeviceIDs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DeviceIDs?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Driver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Driver?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Options

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DiscreteGenericResource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DiscreteGenericResource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Kind?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Value?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DispatcherConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DispatcherConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property HeartbeatPeriod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              HeartbeatPeriod?: Duration | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DNSConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DNSConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Nameservers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nameservers?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Options?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Search?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DockerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DockerOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ca

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cert

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property headers

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                host?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property key

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    port?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Promise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Promise?: typeof Promise | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property protocol

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property socketPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          socketPath?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property sshAuthAgent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sshAuthAgent?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sshOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sshOptions?: ConnectConfig | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property username

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  username?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    version?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DockerVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DockerVersion {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ApiVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ApiVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Arch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Arch: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property BuildTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BuildTime: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Components

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property GitCommit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GitCommit: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property GoVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GoVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property KernelVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    KernelVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property MinAPIVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MinAPIVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Os

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Os: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Platform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Platform: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Driver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Driver {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Options

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EncryptionConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EncryptionConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property AutoLockManagers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AutoLockManagers: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Endpoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Endpoint {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Ports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Ports?: PortConfig[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Spec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Spec?: EndpointSpec | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property VirtualIPs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              VirtualIPs?: EndpointVirtualIP[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EndpointsConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EndpointsConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: EndpointSettings;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EndpointSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EndpointSettings {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Aliases?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property DriverOpts

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property EndpointID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EndpointID?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Gateway

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Gateway?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property GlobalIPv6Address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GlobalIPv6Address?: string