docker-api-nodejs/dist/index.d.ts

Docker API for NodeJS

import * as http from 'http';
import http__default from 'http';
import { Socket } from 'net';

type ModemDialMethod = "GET" | "POST" | "HEAD" | "PUT" | "DELETE" | "PATCH";
type ModemDialResponseResult = object | null;
type ModemDialStreamResult = http__default.IncomingMessage;
type ModemDialResult = ModemDialResponseResult | ModemDialStreamResult | Socket;
interface ModemDialOptions {
    path: string;
    method: ModemDialMethod;
    headers?: Map<string, string>;
    query?: Map<string, Array<string>>;
    body?: object | string;
    isStream?: boolean;
}
declare class Modem {
    private static readonly version;
    private static readonly responseStreamContentType;
    private readonly socketPath;
    constructor(socketPath: string);
    private static responseIsStream;
    private static getResponseContentHandler;
    private static getQueryString;
    dial(options: ModemDialOptions): Promise<ModemDialResult>;
}

declare abstract class Handle {
    protected readonly modem: Modem;
    readonly id: string;
    constructor(modem: Modem, id: string);
}

interface Stackable {
    shouldThrowStackError(): boolean;
}

type WITHOUT<T extends any> = {
    [P in keyof T]?: undefined;
};
type XOR<T extends any, U extends any> = (WITHOUT<T> & U) | (WITHOUT<U> & T);
/**
 * @see https://github.com/microsoft/TypeScript/issues/14094#issuecomment-723571692
 */
type ALLXOR<T extends Array<any>> = T extends [infer Only] ? Only : T extends [infer A, infer B, ...infer Rest] ? ALLXOR<[XOR<A, B>, ...Rest]> : never;
type DockerOptions = {
    [option: string]: string;
};
type DockerLabels = {
    [label: string]: string;
};
type ObjectVersion = {
    Index: number;
};
interface SwarmBase<IDType> {
    ID: IDType;
    Version: ObjectVersion;
    CreatedAt: string;
    UpdatedAt: string;
}
type MountType = "bind" | "volume" | "tmpfs" | "npipe" | "cluster";
interface DockerResouceBase {
    NanoCPUs?: number;
    MemoryBytes?: number;
}
interface Limit extends DockerResouceBase {
    Pids?: number;
}
interface GenericResourcesSpec<ValueType> {
    Kind: string;
    Value: ValueType;
}
type NamedResourceSpec = {
    NamedResourceSpec: GenericResourcesSpec<string>;
};
type DiscreteResourceSpec = {
    DiscreteResourceSpec: GenericResourcesSpec<number>;
};
type GenericResource = XOR<NamedResourceSpec, DiscreteResourceSpec>;
interface ResourceObject extends DockerResouceBase {
    GenericResources?: Array<GenericResource>;
}
type DockerResources = {
    Limits?: Limit;
    Reservations?: ResourceObject;
};
type Platform = {
    Architecture: string;
    OS: string;
};
type Driver = {
    Name: string;
    Options?: DockerOptions;
};
type NetworkAttachementConfig = {
    Target: string;
    Aliases?: Array<string>;
    DriverOpts?: DockerOptions;
};
type PortType = "tcp" | "udp" | "sctp";
type Port = {
    IP?: string;
    PrivatePort: number;
    PublicPort?: number;
    Type: PortType;
};
type EndpointPortConfigPublishMode = "ingress" | "host";
type EndpointPortConfig = {
    Name?: string;
    Protocol: PortType;
    TargetPort: number;
    PublishedPort: number;
    PublishMode: EndpointPortConfigPublishMode;
};
type PortStatus = {
    Ports: Array<EndpointPortConfig>;
};
type EndpointSpecMode = "vip" | "dnsrr";
type EndpointSpec = {
    Mode: EndpointSpecMode;
    Ports: Array<EndpointPortConfig>;
};
type PluginPrivilege = {
    Name: string;
    Description: string;
    Value: Array<string>;
};
type MountBindOptionsPropagation = "private" | "rprivate" | "shared" | "rshared" | "slave" | "rslave";
type MountBindOptions = {
    Propagation: MountBindOptionsPropagation;
    NonRecursive: boolean;
    CreateMountpoint: boolean;
    ReadOnlyNonRecursive: boolean;
    ReadOnlyForceRecursive: boolean;
};
type MountVolumeOptionsDriverConfig = {
    Name: string;
    Options: DockerOptions;
};
type MountVolumeOptions = {
    NoCopy: boolean;
    Labels: DockerLabels;
    DriverConfig: MountVolumeOptionsDriverConfig;
};
type MountTmpfsOptions = {
    SizeBytes: number;
    Mode: number;
};
type MountConsistency = "default" | "consistent" | "cached" | "delegated";
type Mount = {
    Target: string;
    Source: string;
    Type: MountType;
    ReadOnly: boolean;
    Consistency: MountConsistency;
    BindOptions?: MountBindOptions;
    VolumeOptions?: MountVolumeOptions;
    TmpfsOptions?: MountTmpfsOptions;
};
type MountPoint = {
    Type: MountType;
    Name: string;
    Source: string;
    Destination: string;
    Driver: string;
    Mode: string;
    RW: boolean;
    Propagation: string;
};
type HealthCheckResult = {
    Start: string;
    End: string;
    ExitCode: number;
    Output: string;
};
type HealthStatus = "none" | "starting" | "healthy" | "unhealthy";
type Health = {
    Status: HealthStatus;
    FailingStreak: number;
    Log: Array<HealthCheckResult>;
};
/**
 * @see https://docs.docker.com/engine/api/v1.44/#tag/Service/operation/ServiceList
 */
type HealthConfig = {
    Test: Array<string>;
    Interval: number;
    Timeout: number;
    Retries: number;
    StartPeriod: number;
    StartInterval: number;
};
type IPAMConfigAuxiliaryAdresses = {
    [name: string]: string;
};
type IPAMConfig = {
    Subnet: string;
    IPRange: string;
    Gateway: string;
    AuxiliaryAdresses?: IPAMConfigAuxiliaryAdresses;
};
type IPAM = {
    Driver: string;
    Config: Array<IPAMConfig> | null;
    Options: DockerOptions;
};
type EndpointIPAMConfig = {
    IPv4Address: string;
    IPv6Address: string;
    LinkLocalIPs: Array<string>;
};
type EndpointSettings = {
    IPAMConfig: EndpointIPAMConfig | null;
    Links: Array<string>;
    MacAddress: string;
    Aliases: Array<string>;
    NetworkID: string;
    EndpointID: string;
    Gateway: string;
    IPAddress: string;
    IPPrefixLen: number;
    IPv6Gateway: string;
    GlobalIPv6Address: string;
    GlobalIPv6PrefixLen: number;
    DriverOpts: DockerOptions;
    DNSNames: Array<string>;
};
type Topology = {
    [name: string]: string;
};
type EngineDescriptionPlugin = {
    Type: string;
    Name: string;
};
type EngineDescription = {
    EngineVersion: string;
    Labels: DockerLabels;
    Plugins: Array<EngineDescriptionPlugin>;
};
type TLSInfo = {
    TrustRoot: string;
    CertIssuerSubject: string;
    CertIssuerPublicKey: string;
};
type RuntimeStatus = {
    [name: string]: string;
};
type Runtime = {
    path: string;
    runtimeArgs: Array<string> | null;
    status: RuntimeStatus;
};
type PeerNode = {
    NodeID: string;
    Addr: string;
};
type Isolation = "default" | "process" | "hyperv";
type Commit = {
    ID: string;
    Expected: string;
};
type BuildCacheType = "internal" | "frontend" | "source.local" | "source.git.checkout" | "exec.cachemount" | "regular";
type BuildCache = {
    ID: string;
    Parent: string | null;
    Parents: Array<string> | null;
    Type: BuildCacheType;
    Description: string;
    InUse: boolean;
    Shared: boolean;
    Size: number;
    CreatedAt: string;
    LastUsedAt: string | null;
    UsageCount: number;
};
type HostConfigBlkioWeightDevice = {
    Path: string;
    Weight: number;
};
type ThrottleDevice = {
    Path: string;
    Rate: number;
};
type DeviceMapping = {
    PathOnHost: string;
    PathInContainer: string;
    CgroupPermissions: string;
};
type DeviceRequest = {
    Driver: string;
    Count: number;
    DeviceIDs: Array<string>;
    Capabilities: Array<string>;
    Options: DockerOptions;
};
type HostConfigUlimit = {
    Name: string;
    Soft: number;
    Hard: number;
};
type LogConfigType = "json-file" | "syslog" | "journald" | "gelf" | "fluentd" | "awslogs" | "splunk" | "etwlogs" | "none";
type LogConfig = {
    Type: LogConfigType;
    Config: DockerOptions;
};
type PortBinding = {
    HostIp: string;
    HostPort: string;
};
type PortMap = {
    [name: string]: PortBinding;
};
type RestartPolicyName = "" | "no" | "always" | "unless-stopped" | "on-failure";
type RestartPolicy = {
    Name: RestartPolicyName;
    MaximumRetryCount: number;
};
type HostConfigAnnotations = {
    [name: string]: string;
};
type HostConfigCGroupNSMode = "private" | "host";
type HostConfigIpcMode = "none" | "private" | "shareable" | "host";
type HostConfigBase = {
    CpuShares: number;
    Memory: number;
    CgroupParent: string;
    BlkioWeight: number;
    BlkioWeightDevice: Array<HostConfigBlkioWeightDevice>;
    BlkioDeviceReadBps: Array<ThrottleDevice>;
    BlkioDeviceWriteBps: Array<ThrottleDevice>;
    BlkioDeviceReadIOps: Array<ThrottleDevice>;
    BlkioDeviceWriteIOps: Array<ThrottleDevice>;
    CpuPeriod: number;
    CpuQuota: number;
    CpuRealtimePeriod: number;
    CpuRealtimeRuntime: number;
    CpusetCpus: string;
    CpusetMems: string;
    Devices: Array<DeviceMapping>;
    DeviceCgroupRules: Array<string>;
    DeviceRequests: Array<DeviceRequest>;
    KernelMemoryTCP: number;
    MemoryReservation: number;
    MemorySwap: number;
    MemorySwappiness: number;
    NanoCpus: number;
    OomKillDisable: boolean;
    Init: boolean | null;
    PidsLimit: number | null;
    Ulimits: Array<HostConfigUlimit>;
    CpuCount: number;
    CpuPercent: number;
    IOMaximumIOps: number;
    IOMaximumBandwidth: number;
};
type HostConfig = HostConfigBase & {
    Binds: Array<string>;
    ContainerIDFile: string;
    LogConfig: LogConfig;
    NetworkMode: string;
    PortBindings: PortMap;
    RestartPolicy: RestartPolicy;
    AutoRemove: boolean;
    VolumeDriver: string;
    VolumesFrom: Array<string>;
    Mounts: Array<Mount>;
    ConsoleSize: Array<number> | null;
    Annotations: HostConfigAnnotations;
    CapAdd: Array<string>;
    CapDrop: Array<string>;
    CgroupnsMode: HostConfigCGroupNSMode;
    Dns: Array<string>;
    DnsOptions: Array<string>;
    DnsSearch: Array<string>;
    ExtraHosts: Array<string>;
    GroupAdd: Array<string>;
    IpcMode: HostConfigIpcMode;
    Cgroup: string;
    Links: Array<string>;
    OomScoreAdj: number;
    PidMode: string;
    Privileged: boolean;
    PublishAllPorts: boolean;
    ReadonlyRootfs: boolean;
    SecurityOpt: Array<string>;
    StorageOpt: DockerOptions;
    Tmpfs: DockerOptions;
    UTSMode: string;
    UsernsMode: string;
    ShmSize: number;
    Sysctls: DockerOptions;
    Runtime: string;
    Isolation: Isolation;
    MaskedPaths: Array<string>;
    ReadonlyPaths: Array<string>;
};
type GraphDriverData = {
    Name: string;
    Data: DockerOptions;
};
type Address = {
    Addr: string;
    PrefixLen: number;
};
type DockerEventType = "builder" | "config" | "container" | "deamon" | "image" | "network" | "node" | "plugin" | "secret" | "service" | "volume";
type DockerEventScope = "local" | "swarm";
type DockerEventActorAttributes = {
    [Name: string]: string;
};
type DockerEvent = {
    Type: DockerEventType;
    Action: string;
    Actor: {
        ID: string;
        Attributes: DockerEventActorAttributes;
    };
    scope: DockerEventScope;
    time: number;
    timeNano: number;
};

type ConfigId = string;
type ConfigSpec = {
    Name: string;
    Labels?: DockerLabels;
    Data: string;
    Templating?: Driver;
};
interface Config extends SwarmBase<ConfigId> {
    Spec: ConfigSpec;
}
declare class ConfigHandle extends Handle implements Stackable {
    inspect(): Promise<Config>;
    /**
     * @see https://docs.docker.com/engine/api/v1.44/#tag/Config/operation/ConfigUpdate
     * @param spec
     */
    update(spec: ConfigSpec): Promise<void>;
    remove(): Promise<void>;
    shouldThrowStackError(): boolean;
    static isPartOfStack(config: Config): boolean | undefined;
    static fromConfig(modem: Modem, config: Config): ConfigHandle;
}

type ConfigListFilterType = "id" | "label" | "name" | "names";
type ConfigListFilters = Map<ConfigListFilterType, Array<string>>;
type ConfigListResult = Array<Config>;
type ConfigListQueryOptions = {
    filters?: ConfigListFilters;
};
declare class Configs {
    static list(modem: Modem, queryOptions?: ConfigListQueryOptions): Promise<ConfigListResult>;
    static create(modem: Modem, spec: ConfigSpec): Promise<ConfigHandle>;
    static exists(modem: Modem, name: string): Promise<{
        exists: boolean;
        handle: ConfigHandle | undefined;
    }>;
    static getHandle(modem: Modem, id: ConfigId): ConfigHandle;
}

type ContainerId = string;
type ContainerHostConfig = {
    NetworkMode?: string;
};
type ContainerSummaryNetworkSettings = {
    Networks: {
        [name: string]: EndpointSettings;
    };
};
interface ContainerBase {
    Id: ContainerId;
    Image: string;
    Mounts: Array<MountPoint>;
}
interface ContainerSummary extends ContainerBase {
    Names: Array<string>;
    ImageID: string;
    Command: string;
    Created: number;
    Ports: Array<Port>;
    SizeRw: number;
    SizeRootFs: number;
    Labels: DockerLabels;
    State: string;
    Status: string;
    HostConfig: ContainerHostConfig;
    NetworkSettings: ContainerSummaryNetworkSettings;
}
type ContainerStatus = {
    ContainerID: ContainerId;
    PID: string;
    ExitCode: number;
};
/**
 * Format: <port>/<tcp|udp|sctp>: {}
 */
type ContainerSpecExposedPorts = {
    [port: string]: object;
};
type ContainerVolumes = {
    [name: string]: object;
};
type ContainerSpecNetworkingConfig = {
    EndpointsConfig: EndpointSettings;
};
type ContainerConfig = {
    Hostname?: string;
    Domainname?: string;
    User?: string;
    AttachStdin?: boolean;
    AttachStdout?: boolean;
    AttachStderr?: boolean;
    ExposedPorts?: ContainerSpecExposedPorts;
    Tty?: boolean;
    OpenStdin?: boolean;
    StdinOnce?: boolean;
    Env?: Array<string>;
    Cmd?: Array<string>;
    Healthcheck?: HealthConfig;
    ArgsEscaped?: boolean | null;
    Image: string;
    Volumes?: ContainerVolumes;
    WorkingDir?: string;
    Entrypoint?: Array<string>;
    NetworkDisabled?: boolean | null;
    MacAddress?: string | null;
    OnBuild?: Array<string> | null;
    Labels?: DockerLabels;
    StopSignal?: string | null;
    StopTimeout?: number | null;
    Shell?: Array<string> | null;
};
type ContainerSpec = ContainerConfig & {
    HostConfig?: ContainerHostConfig;
    NetworkingConfig?: ContainerSpecNetworkingConfig;
};
type ContainerStateStatus = "created" | "running" | "paused" | "restarting" | "removing" | "exited" | "dead";
type ContainerState = {
    Status: ContainerStateStatus;
    Running: boolean;
    Paused: boolean;
    Restarting: boolean;
    OOMKilled: boolean;
    Dead: boolean;
    Pid: number;
    ExitCode: number;
    Error: string;
    StartedAt: string;
    FinishedAt: string;
    Health: Health;
};
type ContainerNetworkSettings = ContainerSummaryNetworkSettings & {
    Bridge: string;
    SandboxID: string;
    HairpinMode: boolean;
    LinkLocalIPv6Address: string;
    LinkLocalIPv6PrefixLen: number;
    Ports: PortMap;
    SandboxKey: string;
    SecondaryIPAddresses: Array<Address> | null;
    SecondaryIPv6Addresses: Array<Address> | null;
};
interface Container extends ContainerBase {
    Created: string;
    Path: string;
    Args: Array<string>;
    State: ContainerState;
    ResolvConfPath: string;
    HostnamePath: string;
    HostsPath: string;
    LogPath: string;
    Name: string;
    RestartCount: number;
    Driver: string;
    Platform: string;
    MountLabel: string;
    ProcessLabel: string;
    AppArmorProfile: string;
    ExecIds: Array<string> | null;
    HostConfig: HostConfig;
    GraphDriver: GraphDriverData;
    SizeRw: number;
    SizeRootFs: number;
    Mounts: Array<MountPoint>;
    Config: ContainerConfig;
    NetworkSettings: ContainerNetworkSettings;
}
type ContainerUpdateConfig = HostConfigBase & {
    RestartPolicy: RestartPolicy;
};
type ContainerInspectQueryOptions = {
    size?: boolean;
};
type ContainerListProcessesQueryOptions = {
    ps_args?: string;
};
type ContainerLogsQueryOptions = {
    follow?: boolean;
    stdout?: boolean;
    stderr?: boolean;
    since?: number;
    until?: number;
    timestamps?: boolean;
    tail?: "all" | number;
};
type ContainerListProcessesResult = {
    Titles: Array<string>;
    Processes: Array<Array<string>>;
};
type ContainerChangesResult = Array<{
    Path: string;
    Kind: 0 | 1 | 2;
}>;
type ContainerStatsQueryOptions = {
    stream?: boolean;
    /**
     * Has to be used with stream=false
     * Returns values immediately instead of waiting 2 cycles
     */
    oneShot?: boolean;
};
type ContainerResizeQueryOptions = {
    w: number;
    h: number;
};
type ContainerStartQueryOptions = {
    detachKeys?: string;
};
type ContainerKillQueryOptions = {
    signal?: string;
};
type ContainerStopQueryOptions = ContainerKillQueryOptions & {
    t?: number;
};
type ContainerRenameQueryOptions = {
    name: string;
};
type ContainerWaitQueryOptions = {
    condition?: "not-running" | "next-exit" | "removed";
};
type ContainerRemoveQueryOptions = {
    v?: boolean;
    force?: boolean;
    link?: boolean;
};
type ContainerUpdateResult = {
    Warnings: Array<string>;
};
declare class ContainerHandle extends Handle {
    inspect(queryOptions?: ContainerInspectQueryOptions): Promise<Container>;
    listProcesses(queryOptions?: ContainerListProcessesQueryOptions): Promise<ContainerListProcessesResult>;
    getLogs(queryOptions?: ContainerLogsQueryOptions): Promise<http.IncomingMessage>;
    changes(): Promise<ContainerChangesResult>;
    export(): Promise<http.IncomingMessage>;
    stats(queryOptions?: ContainerStatsQueryOptions): Promise<http.IncomingMessage>;
    resize(queryOptions: ContainerResizeQueryOptions): Promise<ModemDialResult>;
    start(queryOptions?: ContainerStartQueryOptions): Promise<ModemDialResult>;
    stop(queryOptions?: ContainerStopQueryOptions): Promise<ModemDialResult>;
    restart(queryOptions?: ContainerStopQueryOptions): Promise<ModemDialResult>;
    kill(queryOptions?: ContainerKillQueryOptions): Promise<ModemDialResult>;
    update(updateConfig: ContainerUpdateConfig): Promise<ContainerUpdateResult>;
    rename(queryOptions: ContainerRenameQueryOptions): Promise<ModemDialResult>;
    pause(): Promise<ModemDialResult>;
    unpause(): Promise<ModemDialResult>;
    wait(queryOptions?: ContainerWaitQueryOptions): Promise<ModemDialResult>;
    remove(queryOptions?: ContainerRemoveQueryOptions): Promise<void>;
    static fromContainer(modem: Modem, container: ContainerSummary): ContainerHandle;
}

type ContainerListFilterType = "ancestor" | "before" | "expose" | "exited" | "isolation" | "is-task" | "label" | "name" | "network" | "publish" | "since" | "status" | "volume";
type ContainerListFilters = Map<ContainerListFilterType, Array<string>>;
type ContainerPruneFilterType = "until" | "label";
type ContainerPruneFilters = Map<ContainerPruneFilterType, Array<string>>;
type ContainerListQueryOptions = {
    all?: boolean;
    limit?: number;
    size?: boolean;
    filters?: ContainerListFilters;
};
type ContainerPruneQueryOptions = {
    filters?: ContainerPruneFilters;
};
type ContainerListResult = Array<ContainerSummary>;
type ContainerPruneResult = {
    ContainersDeleted: Array<string>;
    SpaceReclaimed: number;
};
declare class Containers {
    static list(modem: Modem, queryOptions?: ContainerListQueryOptions): Promise<ContainerListResult>;
    static create(modem: Modem, spec: ContainerSpec): Promise<ContainerHandle>;
    static prune(modem: Modem, queryOptions?: ContainerPruneQueryOptions): Promise<ContainerPruneResult>;
    static getHandle(modem: Modem, id: ContainerId): ContainerHandle;
}

type ImageId = string;
type ImageConfig = ContainerConfig;
interface ImageBase {
    Id: ImageId;
    ParentId: ImageId;
    RepoTags: Array<string>;
    RepoDigests: Array<string>;
    Created: number;
    Size: number;
    VirtualSize?: number;
}
interface ImageSummary extends ImageBase {
    SharedSize: number;
    Labels: DockerLabels;
    Containers: number;
}
type ImageRootFS = {
    Type: string;
    Layers: Array<string>;
};
type ImageMetadata = {
    LastTagTime: string | null;
};
interface Image extends ImageBase {
    Comment: string;
    Container: string;
    ContainerConfig: ContainerConfig;
    DockerVersion: string;
    Author: string;
    Config: ImageConfig;
    Architecture: string;
    Variant: string;
    Os: string;
    OsVersion: string;
    GraphDriver: GraphDriverData;
    RootFS: ImageRootFS;
    Metadata: ImageMetadata;
}
type ImageLayer = {
    Id: string;
    Created: number;
    CreatedBy: string;
    Tags: Array<string>;
    Size: number;
    Comment: string;
};
type ImageHistoryResult = Array<ImageLayer>;
type ImagePushQueryOptions = {
    tag?: string;
};
type ImageTagQueryOptions = {
    repo: string;
    tag: string;
};
type ImageRemoveQueryOptions = {
    force?: boolean;
    noprune?: false;
};
declare class ImageHandle extends Handle {
    inspect(): Promise<Image>;
    history(): Promise<ImageHistoryResult>;
    push(queryOptions?: ImagePushQueryOptions, registryAuth?: string): Promise<ModemDialResult>;
    tag(queryOptions: ImageTagQueryOptions): Promise<ModemDialResult>;
    remove(queryOptions?: ImageRemoveQueryOptions): Promise<void>;
    static fromImage(modem: Modem, image: Image): ImageHandle;
}

declare class HandleLogWrapper<HandleType extends Handle> {
    private readonly handle;
    private readonly logStream?;
    private readonly logChunks;
    constructor(handle: HandleType, logStream?: ModemDialStreamResult);
    drainLogStream(): Promise<void>;
    get Handle(): HandleType;
    get LogChunks(): string[];
}

type ImageListFilterType = "before" | "dangling" | "label" | "reference" | "since" | "until";
type ImageBuildPruneFilterType = "until" | "id" | "parent" | "type" | "description" | "inuse" | "shared" | "private";
type ImageSearchFilterTypes = "is-official" | "stars";
type ImagePruneFilterType = "dangling" | "until" | "label";
type ImageListFilters = Map<ImageListFilterType, Array<string>>;
type ImageBuildPruneFilters = Map<ImageBuildPruneFilterType, Array<string>>;
type ImageSearchFilters = Map<ImageSearchFilterTypes, Array<string>>;
type ImagePruneFilters = Map<ImagePruneFilterType, Array<string>>;
type ImageListQueryOptions = {
    all?: boolean;
    filters?: ImageListFilters;
    sharedSize?: boolean;
    digests?: boolean;
};
type ImageBuildPruneQueryOptions = {
    keepStorage: number;
    all: boolean;
    filters?: ImageBuildPruneFilters;
};
type ImagePullQueryOptions = {
    fromImage: string;
    tag?: string;
    changes?: Array<string>;
    platform?: string;
};
type ImageImportQueryOptions = {
    fromSrc: string;
    repo: string;
    message?: string;
    changes?: Array<string>;
    platform?: string;
};
type ImageSearchQueryOptions = {
    term: string;
    limit: number;
    filters?: ImageSearchFilters;
};
type ImageCommitQueryOptions = {
    container?: string;
    repo: string;
    tag?: string;
    comment?: string;
    author?: string;
    pause?: boolean;
    changes?: string;
};
type ImageListResult = Array<ImageSummary>;
type ImageBuildPruneResult = {
    CachesDeleted: Array<string>;
    SpaceReclaimed: number;
};
type ImagePruneResultImageDeleted = {
    Untagged: string;
    Deleted: string;
};
type ImageSearchResult = Array<{
    description: string;
    is_official: boolean;
    name: string;
    star_count: number;
}>;
type ImagePruneResult = {
    ImagesDeleted: Array<ImagePruneResultImageDeleted>;
    SpaceReclaimed: number;
};
type ImageCommitResult = {
    Id: string;
};
declare class Images {
    static list(modem: Modem, queryOptions?: ImageListQueryOptions): Promise<ImageListResult>;
    static pruneBuilderCache(modem: Modem, queryOptions: ImageBuildPruneQueryOptions): Promise<ImageBuildPruneResult>;
    /**
     * @see https://docs.docker.com/reference/api/engine/version/v1.44/#tag/Image/operation/ImageCreate
     *
     * @param modem
     * @param queryOptions
     * @param registryAuth
     * @returns
     */
    static pull(modem: Modem, queryOptions: ImagePullQueryOptions, registryAuth?: string): Promise<HandleLogWrapper<ImageHandle>>;
    /**
     * @see https://docs.docker.com/reference/api/engine/version/v1.44/#tag/Image/operation/ImageCreate
     *
     * @param modem
     * @param queryOptions
     * @param image
     * @returns
     */
    static import(modem: Modem, queryOptions: ImageImportQueryOptions, image?: string): Promise<HandleLogWrapper<ImageHandle>>;
    static search(modem: Modem, queryOptions: ImageSearchQueryOptions): Promise<ImageSearchResult>;
    static prune(modem: Modem, filters?: ImagePruneFilters): Promise<ImagePruneResult>;
    /**
     * Creates a new image based on a container configuration
     * @param modem the modem to communicate with docker
     * @param queryOptions query specific options
     * @param containerConfig configuration of the container for the image
     */
    static commit(modem: Modem, queryOptions: ImageCommitQueryOptions, containerConfig?: ContainerConfig): Promise<ImageCommitResult>;
    static getHandle(modem: Modem, id: ImageId): ImageHandle;
}

type NetworkId = string;
type NetworkScope = "local" | "swarm";
type NetworkContainer = {
    Name: string;
    EndpointID: string;
    MacAddress: string;
    IPv4Address: string;
    IPv6Address: string;
};
type NetworkContainers = {
    [name: string]: NetworkContainer;
};
type NetworkConfigFrom = {
    Network: NetworkId;
};
interface NetworkSpec {
    Name: string;
    Driver?: string;
    EnableIPv6?: boolean;
    IPAM?: IPAM;
    Internal?: boolean;
    Attachable?: boolean;
    Ingress?: boolean;
    Options?: DockerOptions;
    Labels?: DockerLabels;
    Scope?: NetworkScope;
    ConfigOnly?: boolean;
    ConfigFrom?: NetworkConfigFrom;
}
interface Network extends NetworkSpec {
    Id: NetworkId;
    Created: string;
    Containers: NetworkContainers;
}
type NetworkInspectQueryOptions = {
    verbose?: boolean;
    scope?: NetworkScope;
};
type NetworkConnectContainerConfig = {
    Container: string;
    EndpointConfig: EndpointSettings;
};
type NetworkDisconnectContainerConfig = {
    Container: string;
    Force: boolean;
};
declare class NetworkHandle extends Handle implements Stackable {
    /**
     * @see https://docs.docker.com/engine/api/v1.44/#tag/Network/operation/NetworkInspect
     * @param queryOptions query options to use
     */
    inspect(queryOptions?: NetworkInspectQueryOptions): Promise<Network>;
    remove(): Promise<void>;
    connectContainer(connectConfig: NetworkConnectContainerConfig): Promise<ModemDialResult>;
    disconnectContainer(disconnectConfig: NetworkDisconnectContainerConfig): Promise<ModemDialResult>;
    shouldThrowStackError(): boolean;
    static isPartOfStack(network: Network): boolean | undefined;
    static fromNetwork(modem: Modem, network: Network): NetworkHandle;
}

type NetworkListFilterType = "dangling" | "driver" | "id" | "label" | "name" | "scope" | "type";
type NetworkPruneFilterType = "until" | "label";
type NetworkListFilters = Map<NetworkListFilterType, Array<string>>;
type NetworkPruneFilters = Map<NetworkPruneFilterType, Array<string>>;
type NetworkListQueryOptions = {
    filters?: NetworkListFilters;
};
type NetworkPruneQueryOptions = {
    filters?: NetworkPruneFilters;
};
type NetworkListResult = Array<Network>;
type NetworkPruneResult = {
    NetworksDeleted: Array<string>;
};
declare class Networks {
    /**
     * @see https://docs.docker.com/engine/api/v1.44/#tag/Network/operation/NetworkList
     */
    static list(modem: Modem, queryOptions?: NetworkListQueryOptions): Promise<NetworkListResult>;
    /**
     * @see https://docs.docker.com/engine/api/v1.44/#tag/Network/operation/NetworkCreate
     *
     * @param modem the modem to use
     * @param spec the spec to use to create the network
     */
    static create(modem: Modem, spec: NetworkSpec): Promise<NetworkHandle>;
    static existsCluster(modem: Modem, name: string): Promise<{
        exists: boolean;
        handle: NetworkHandle | undefined;
    }>;
    static prune(modem: Modem, queryOptions?: NetworkPruneQueryOptions): Promise<NetworkPruneResult>;
    static getHandle(modem: Modem, id: NetworkId): NetworkHandle;
}

type NodeId = string;
type NodeRole = "worker" | "manager";
type NodeAvailability = "active" | "pause" | "drain";
type NodeSpec = {
    Name: string;
    Labels?: DockerLabels;
    Role: NodeRole;
    Availability: NodeAvailability;
};
type NodeDescription = {
    Hostname: string;
    Platform: Platform;
    Resources: ResourceObject;
    Engine: EngineDescription;
    TLSInfo: TLSInfo;
};
type NodeState = "unknown" | "down" | "ready" | "disconnected";
type NodeStatus = {
    State: NodeState;
    Message: string;
    Addr: string;
};
type NodeManagerStatusReachability = "unknown" | "unreachable" | "reachable";
type NodeManagerStatus = {
    Leader: boolean;
    Reachability: NodeManagerStatusReachability;
    Addr: string;
};
interface Node extends SwarmBase<NodeId> {
    Spec: NodeSpec;
    Description: NodeDescription;
    Status: NodeStatus;
    ManagerStatus: NodeManagerStatus;
}
type NodeRemoveQueryOptions = {
    force?: boolean;
};
declare class NodeHandle extends Handle {
    inspect(): Promise<Node>;
    update(newSpec: NodeSpec): Promise<void>;
    remove(queryOptions: NodeRemoveQueryOptions): Promise<void>;
    static fromNode(modem: Modem, node: Node): NodeHandle;
}

type NodeListFilterType = "id" | "label" | "membership" | "name" | "node.label" | "role";
type NodeListFilters = Map<NodeListFilterType, Array<string>>;
type NodeListResult = Array<Node>;
type NodeListQueryOptions = {
    filters?: NodeListFilters;
};
declare class Nodes {
    static list(modem: Modem, queryOptions?: NodeListQueryOptions): Promise<NodeListResult>;
    static getHandle(modem: Modem, id: NodeId): NodeHandle;
}

type PluginId = string;
type PluginMount = {
    Name: string;
    Description: string;
    Settable: Array<string>;
    Source: string;
    Destination: string;
    Type: string;
    Options: Array<string>;
};
type PluginDevice = {
    Name: string;
    Description: string;
    Settable: Array<string>;
    Path: string;
};
type PluginSettings = {
    Mounts: Array<PluginMount>;
    Env: Array<string>;
    Args: Array<string>;
    Devices: Array<PluginDevice>;
};
type PluginInterfaceType = {
    Prefix: string;
    Capability: string;
    Version: string;
};
type PluginInterfaceProtocolScheme = "" | "moby.plugins.http/v1";
type PluginInterface = {
    Types: Array<PluginInterfaceType>;
    Socket: string;
    ProtocolScheme: PluginInterfaceProtocolScheme;
};
type PluginUser = {
    UID: number;
    GID: number;
};
type PluginNetwork = {
    Type: string;
};
type PluginLinux = {
    Capabilities: Array<string>;
    AllowAllDevices: boolean;
    Devices: Array<PluginDevice>;
};
type PluginEnv = {
    Name: string;
    Description: string;
    Settable: Array<string>;
    Value: string;
};
type PluginArgs = {
    Name: string;
    Description: string;
    Settable: Array<string>;
    Value: Array<string>;
};
type PluginRootfs = {
    type: string;
    diff_ids: Array<string>;
};
type PluginConfig = {
    Docker: string;
    Description: string;
    Documentation: string;
    Interface: PluginInterface;
    Entrypoint: Array<string>;
    WorkDir: string;
    User: PluginUser;
    Network: PluginNetwork;
    Linux: PluginLinux;
    PopagatedMount: string;
    IpcHost: boolean;
    PidHost: boolean;
    Mounts: Array<PluginMount>;
    Env: Array<PluginEnv>;
    Args: PluginArgs;
    rootfs: PluginRootfs;
};
interface Plugin {
    Id: PluginId;
    Name: string;
    Enabled: boolean;
    Settings: PluginSettings;
    PluginReference: string;
    Config: PluginConfig;
}
type PluginRemoveQueryOptions = {
    force?: boolean;
};
type PluginEnableQueryOptions = {
    timeout?: number;
};
type PluginDisableQueryOptions = {
    force?: boolean;
};
declare class PluginHandle extends Handle {
    inspect(): Promise<Plugin>;
    remove(queryOptions?: PluginRemoveQueryOptions): Promise<void>;
    enable(queryOptions?: PluginEnableQueryOptions): Promise<void>;
    disable(queryOptions?: PluginDisableQueryOptions): Promise<void>;
    static fromPlugin(modem: Modem, plugin: Plugin): PluginHandle;
}

type PluginListFilterType = "capability" | "enable";
type PluginListFilters = Map<PluginListFilterType, Array<string>>;
type PluginListResult = Array<Plugin>;
type PluginListQueryOptions = {
    filters?: PluginListFilters;
};
type PluginGetPrivilegesQueryOptions = {
    remote: string;
};
type PluginGetPrivilegesResult = Array<PluginPrivilege>;
type PluginInstallQueryOptions = PluginGetPrivilegesQueryOptions & {
    name?: string;
};
declare class Plugins {
    static list(modem: Modem, queryOptions?: PluginListQueryOptions): Promise<PluginListResult>;
    /**
     *
     * @param modem modem to use
     * @param queryOptions query options to use
     * @param registryAuth is not included in docker api docs but is required for private repos to correctly return privileges
     * @returns
     */
    static getPrivileges(modem: Modem, queryOptions: PluginGetPrivilegesQueryOptions, registryAuth?: string): Promise<PluginGetPrivilegesResult>;
    static install(modem: Modem, queryOptions: PluginInstallQueryOptions, privileges: Array<PluginPrivilege>, registryAuth?: string): Promise<HandleLogWrapper<PluginHandle>>;
    static installGrantAllPrivileges(modem: Modem, queryOptions: PluginInstallQueryOptions, registryAuth?: string): Promise<HandleLogWrapper<PluginHandle>>;
    static getHandle(modem: Modem, id: PluginId): PluginHandle;
}

type SwarmSpecOrchestration = {
    TaskHistoryRetentionLimit: number;
};
type SwarmSpecRaft = {
    SnapshotInterval: number;
    KeepOldSnapshots: number;
    LogEntriesForSlowFollowers: number;
    ElectionTick: number;
    HeartbeatTick: number;
};
type SwarmSpecDispatcher = {
    HeartbeatPeriod: number;
};
type SwamSpecCAConfigExternalCAProtocol = "cfssl";
type SwamSpecCAConfigExternalCA = {
    Protocol: SwamSpecCAConfigExternalCAProtocol;
    URL: string;
    Options: DockerOptions;
    CACert: string;
};
type SwarmSpecCAConfig = {
    NodeCertExpiry: number;
    ExternalCAs: Array<SwamSpecCAConfigExternalCA>;
    SigningCACert: string;
    SigningCAKey: string;
    ForceRotate: number;
};
type SwarmSpecEncryptionConfig = {
    AutoLockManagers: boolean;
};
type SwarmSpecTaskDefaults = {
    LogDriver: Driver;
};
type SwarmSpec = {
    Name: string;
    Labels: DockerLabels;
    Orchestration: SwarmSpecOrchestration | null;
    Raft: SwarmSpecRaft;
    Dispatcher: SwarmSpecDispatcher;
    CAConfig: SwarmSpecCAConfig;
    EncryptionConfig: SwarmSpecEncryptionConfig;
    TaskDefaults: SwarmSpecTaskDefaults;
};
interface SwarmCluster extends SwarmBase<string> {
    Spec: SwarmSpec;
    TLSInfo: TLSInfo;
    RootRotationInProgress: boolean;
    DataPathPort: number;
    DefaultAddrPool: Array<Array<string>>;
    SubnetSize: number;
}
type SwarmInitSpecBase = {
    ListenAddr: string;
    AdvertiseAddr: string;
    DataPathAddr?: string;
};
type SwarmInitSpec = SwarmInitSpecBase & {
    DataPathPort: number;
    DefaultAddrPool: Array<string>;
    ForceNewCluster: boolean;
    SubnetSize: number;
    Spec: SwarmSpec;
};
type SwarmJoinSpec = SwarmInitSpecBase & {
    RemoteAddrs: Array<string>;
    JoinToken: string;
};
type SwarmLeaveQueryOptions = {
    force?: boolean;
};
type SwarmUpdateQueryOptions = {
    rotateWorkerToken?: boolean;
    rotateManagerToken?: boolean;
    rotateManagerUnlockKey?: boolean;
};
type SwarmUnlockSpec = {
    UnlockKey: string;
};
declare class Swarm {
    static inspect(modem: Modem): Promise<SwarmCluster>;
    static initialize(modem: Modem, initSpec: SwarmInitSpec): Promise<ModemDialResult>;
    static join(modem: Modem, joinSpec: SwarmJoinSpec): Promise<ModemDialResult>;
    static leave(modem: Modem, queryOptions?: SwarmLeaveQueryOptions): Promise<ModemDialResult>;
    static update(modem: Modem, queryOptions: SwarmUpdateQueryOptions | undefined, spec: SwarmSpec): Promise<ModemDialResult>;
    static getUnlockKey(modem: Modem): Promise<ModemDialResult>;
    static unlock(modem: Modem, unlockSpec: SwarmUnlockSpec): Promise<ModemDialResult>;
}

type SecretId = string;
interface SecretSpecBase {
    Name: string;
    Labels?: DockerLabels;
    Driver?: Driver;
    Templating?: Driver;
}
interface SecretSpec extends SecretSpecBase {
    Data: string;
}
interface Secret extends SwarmBase<SecretId> {
    Spec: SecretSpecBase;
}
declare class SecretHandle extends Handle implements Stackable {
    inspect(): Promise<Secret>;
    /**
     * @see https://docs.docker.com/engine/api/v1.44/#tag/Secret/operation/SecretUpdate
     * @param spec
     */
    update(spec: SecretSpec): Promise<void>;
    remove(): Promise<void>;
    shouldThrowStackError(): boolean;
    static isPartOfStack(secret: Secret): boolean | undefined;
    static fromSecret(modem: Modem, secret: Secret): SecretHandle;
}

type SecretListFilterType = "id" | "label" | "name" | "names";
type SecretListFilters = Map<SecretListFilterType, Array<string>>;
type SecretListResult = Array<Secret>;
type SecretListQueryOptions = {
    filters?: SecretListFilters;
};
declare class Secrets {
    static list(modem: Modem, queryOptions?: SecretListQueryOptions): Promise<SecretListResult>;
    static create(modem: Modem, spec: SecretSpec): Promise<SecretHandle>;
    static exists(modem: Modem, name: string): Promise<{
        exists: boolean;
        handle: SecretHandle | undefined;
    }>;
    static getHandle(modem: Modem, id: SecretId): SecretHandle;
}

type TaskId = string;
type TaskPluginSpec = {
    Name: string;
    Remote: string;
    Disabled: boolean;
    PluginPrivileges: Array<PluginPrivilege>;
};
type TaskContainerPrivilegesCredentialSpec = {
    Config: string;
    File: string;
    Registry: string;
};
type TaskContainerPrivilegesSELinuxContext = {
    Disable: boolean;
    User: string;
    Role: string;
    Type: string;
    Level: string;
};
type TaskContainerPrivilegesSeccompMode = "default" | "unconfined" | "custom";
type TaskContainerPrivilegesSeccomp = {
    Mode: TaskContainerPrivilegesSeccompMode;
    Profile: string;
};
type TaskContainerPrivilegesAppArmorMode = "default" | "disabled";
type TaskContainerPrivilegesAppArmor = {
    Mode: TaskContainerPrivilegesAppArmorMode;
};
type TaskContainerPrivileges = {
    CredentialSpec: TaskContainerPrivilegesCredentialSpec;
    SELinuxContext: TaskContainerPrivilegesSELinuxContext;
    Seccomp: TaskContainerPrivilegesSeccomp;
    AppArmor: TaskContainerPrivilegesAppArmor;
    NoNewPrivileges: boolean;
};
type TaskContainerDNSConfig = {
    NameServers: Array<string>;
    Search: Array<string>;
    Options: Array<string>;
};
type TaskContainerFile = {
    Name: string;
    UID: string;
    GID: string;
    Mode: number;
};
type TaskContainerSecret = {
    File: TaskContainerFile;
    SecretID: string;
    SecretName: string;
};
type TaskContainerConfigFile = {
    File: TaskContainerFile;
};
type TaskContainerConfigRuntime = {
    Runtime: object;
};
type TaskContainerConfigBase = {
    ConfigID: string;
    ConfigName: string;
};
type TaskContainerConfig = XOR<TaskContainerConfigFile, TaskContainerConfigRuntime> & TaskContainerConfigBase;
type TaskContainerSysctls = {
    [name: string]: string;
};
type TaskContainerUlimit = {
    Name: string;
    Soft: number;
    Hard: number;
};
type TaskContainerSpec = {
    Image: string;
    Labels?: DockerLabels;
    Command?: Array<string>;
    Args?: Array<string>;
    Hostname?: string;
    Env?: Array<string>;
    Dir?: string;
    User?: string;
    Groups?: Array<string>;
    Privileges?: TaskContainerPrivileges;
    TTY?: boolean;
    OpenStdin?: boolean;
    ReadOnly?: boolean;
    Mounts?: Array<Mount>;
    StopSignal?: string;
    StopGracePeriod?: number;
    HealthCheck?: HealthConfig;
    Hosts?: Array<string>;
    DNSConfig?: TaskContainerDNSConfig;
    Secrets?: Array<TaskContainerSecret>;
    Configs?: Array<TaskContainerConfig>;
    Isolation?: Isolation;
    Init?: boolean | null;
    Sysctls?: TaskContainerSysctls;
    CapabilityAdd?: Array<string>;
    CapabilityDrop?: Array<string>;
    Ulimits?: Array<TaskContainerUlimit>;
};
type TaskNetworkAttachmentSpec = {
    ContainerID: ContainerId;
};
type TaskRestartPolicyCondition = "none" | "on-failure" | "any";
type TaskRestartPolicy = {
    Condition: TaskRestartPolicyCondition;
    Delay: number;
    MaxAttempts: number;
    Window: number;
};
type TaskPlacementPreferenceSpread = {
    SpreadDescriptor: string;
};
type TaskPlacementPreference = {
    Spread: TaskPlacementPreferenceSpread;
};
/**
 * @see https://docs.docker.com/engine/api/v1.44/#tag/Service/operation/ServiceList
 */
type TaskPlacement = {
    Constraints: Array<string>;
    Preferences: Array<TaskPlacementPreference>;
    MaxReplicas: number;
    Platforms: Array<Platform>;
};
type TaskSpecBase = {
    Resources?: DockerResources;
    RestartPolicy?: TaskRestartPolicy;
    Placement?: TaskPlacement;
    ForceUpdate?: number;
    Runtime?: string;
    Networks?: Array<NetworkAttachementConfig>;
    LogDriver?: Driver;
};
type PluginTaskSpec = {
    PluginSpec: TaskPluginSpec;
};
type ContainerTaskSpec = {
    ContainerSpec: TaskContainerSpec;
};
type NetworkAttachmentTaskSpec = {
    NetworkAttachmentSpec: TaskNetworkAttachmentSpec;
};
type TaskSpec = ALLXOR<[PluginTaskSpec, ContainerTaskSpec, NetworkAttachmentTaskSpec]> & TaskSpecBase;
type TaskState = "new" | "allocated" | "pending" | "assigned" | "accepted" | "preparing" | "ready" | "starting" | "running" | "complete" | "shutdown" | "failed" | "rejected" | "remove" | "orphaned";
type TaskStatus = {
    Timestamp: string;
    State: TaskState;
    Message: string;
    Err: string;
    ContainerStatus?: ContainerStatus;
    PortStatus: PortStatus;
};
interface Task extends SwarmBase<TaskId> {
    Name: string;
    Labels: DockerLabels;
    Spec: TaskSpec;
    ServiceID: ServiceId;
    Slot: number;
    NodeID: NodeId;
    AssignedGenericResources: Array<GenericResource>;
    Status: TaskStatus;
    Desired: TaskState;
    JobIteration: ObjectVersion;
}
type TaskLogsQueryOptions = {
    details?: boolean;
    follow?: boolean;
    stdout?: boolean;
    stderr?: boolean;
    since?: number;
    timestamps?: boolean;
    tail?: string | "all";
};
declare class TaskHandle extends Handle {
    inspect(): Promise<Task>;
    getLogs(queryOptions?: TaskLogsQueryOptions): Promise<http.IncomingMessage>;
    static fromTask(modem: Modem, task: Task): TaskHandle;
}

type ServiceId = string;
type ServiceModeReplicated = {
    Replicas: number;
};
type ServiceModeReplicatedJob = {
    MaxConcurrent: number;
    TotalCompletions: number;
};
type ServiceModeReplicatedWrapper = {
    Replicated: ServiceModeReplicated;
};
type ServiceModeReplicatedJobWrapper = {
    ReplicatedJob: ServiceModeReplicatedJob;
};
type ServiceModeGlobalWrapper = {
    Global: object;
};
type ServiceModeGlobalJobWrapper = {
    GlobalJob: object;
};
type ServiceMode = ALLXOR<[ServiceModeReplicatedWrapper, ServiceModeReplicatedJobWrapper, ServiceModeGlobalWrapper, ServiceModeGlobalJobWrapper]>;
type ServiceConfigOrder = "stop-first" | "start-first";
interface ServiceConfig<FailureActionType extends string> {
    Parallelism: number;
    Delay: number;
    FailureAction: FailureActionType;
    Monitor: number;
    MaxFailureRatio: number;
    Order: ServiceConfigOrder;
}
type ServiceUpdateConfigFailureAction = "continue" | "pause" | "rollback";
type ServiceRollbackConfigFailureAction = "continue" | "pause";
type ServiceSpec = {
    Name?: string;
    Labels?: DockerLabels;
    TaskTemplate: TaskSpec;
    Mode?: ServiceMode;
    UpdateConfig?: ServiceConfig<ServiceUpdateConfigFailureAction>;
    RollbackConfig?: ServiceConfig<ServiceRollbackConfigFailureAction>;
    Networks?: Array<NetworkAttachementConfig>;
    EndpointSpec?: EndpointSpec;
};
type ServiceEndpointVirtualIP = {
    NetworkID: NetworkId;
    Addr: string;
};
type ServiceEndpoint = {
    Spec: EndpointSpec;
    Ports?: Array<EndpointPortConfig>;
    VirtualIPs?: Array<ServiceEndpointVirtualIP>;
};
type ServiceUpdateStatusState = "updating" | "paused" | "completed";
type ServiceUpdateStatus = {
    State: ServiceUpdateStatusState;
    StartedAt: string;
    CompletedAt: string;
    Message: string;
};
type ServiceServiceStatus = {
    RunningTasks: number;
    DesiredTasks: number;
    CompletedTasks: number;
};
type ServiceJobStatus = {
    JobIteration: ObjectVersion;
    LastExecution: string;
};
interface Service extends SwarmBase<ServiceId> {
    Spec: ServiceSpec;
    PreviousSpec?: ServiceSpec;
    Endpoint: ServiceEndpoint;
    UpdateStatus: ServiceUpdateStatus;
    ServiceStatus: ServiceServiceStatus;
    JobStatus: ServiceJobStatus;
}
type ServiceInspectQueryOptions = {
    insertDefaults?: boolean;
};
type ServiceLogsQueryOptions = {
    details?: boolean;
    follow?: boolean;
    stdout?: boolean;
    stderr?: boolean;
    since?: number;
    timestamps?: boolean;
    tail?: number | "all";
};
type ServiceUpdateQueryOptionsRegistryAuthFrom = "spec" | "previous-spec";
type ServiceRollbackQueryOptions = {
    registryAuthFrom?: ServiceUpdateQueryOptionsRegistryAuthFrom;
};
type ServiceUpdateQueryOptions = ServiceRollbackQueryOptions & {
    rollback?: string;
};
type ServiceUpdateResult = {
    Warnings: Array<string>;
};
declare class ServiceHandle extends Handle implements Stackable {
    inspect(queryOptions?: ServiceInspectQueryOptions): Promise<Service>;
    /**
     * @see https://docs.docker.com/engine/api/v1.44/#tag/Service/operation/ServiceLogs
     *
     * @param queryOptions the query options to use
     */
    getLogs(queryOptions?: ServiceLogsQueryOptions): Promise<http.IncomingMessage>;
    /**
     * @see https://docs.docker.com/engine/api/v1.44/#tag/Service/operation/ServiceUpdate
     *
     * @param newSpec the new spec for the service
     * @param queryOptions the query options to use
     * @param registryAuth the authentication to connect to a private registry if needed
     */
    update(newSpec: ServiceSpec, queryOptions?: ServiceUpdateQueryOptions, registryAuth?: string): Promise<ServiceUpdateResult>;
    /**
     * Removes this service and creates a new one with the same spec
     * @param registryAuth
     */
    redeploy(registryAuth?: string): Promise<ServiceHandle>;
    rollback(queryOptions?: ServiceRollbackQueryOptions, registryAuth?: string): Promise<ServiceUpdateResult>;
    stop(): Promise<ServiceUpdateResult>;
    /**
     * This will start a stopped service.
     * Be careful tho, because it does a server side redeploy to the last running spec.
     * And it only does that if the service is not running
     */
    start(): Promise<ServiceUpdateResult>;
    remove(): Promise<ModemDialResult>;
    shouldThrowStackError(): boolean;
    static isPartOfStack(service: Service): boolean | undefined;
    static fromService(modem: Modem, service: Service): ServiceHandle;
}

type ServiceListFilterType = "id" | "label" | "mode" | "name";
type ServiceListFilters = Map<ServiceListFilterType, Array<string>>;
type ServiceListResult = Array<Service>;
type ServiceListQueryOptions = {
    filters?: ServiceListFilters;
    status?: boolean;
};
declare class Services {
    /**
     * @see https://docs.docker.com/engine/api/v1.44/#tag/Service/operation/ServiceList
     *
     * @param modem the modem to use
     * @param filters the filters to use
     * @param status include service status
     */
    static list(modem: Modem, queryOptions?: ServiceListQueryOptions): Promise<ServiceListResult>;
    static create(modem: Modem, spec: ServiceSpec, registryAuth?: string): Promise<ServiceHandle>;
    static exists(modem: Modem, name: string): Promise<{
        exists: boolean;
        handle: ServiceHandle | undefined;
    }>;
    static getHandle(modem: Modem, id: ServiceId): ServiceHandle;
}

type DockerVolumeStatus = {
    [key: string]: string;
};
type VolumeScope = "local" | "global";
type VolumeUsageData = {
    Size: number;
    RefCount: number;
};
interface VolumeSpec {
    Name?: string;
    Driver?: string;
    DriverOpts?: DockerOptions;
    Labels?: DockerLabels;
}
interface Volume {
    Name: string;
    Driver: string;
    Mountpoint: string;
    CreatedAt: string;
    Status: DockerVolumeStatus;
    Labels: DockerLabels;
    Scope: VolumeScope;
    Options: DockerOptions;
    UsageData: VolumeUsageData | null;
}
type VolumeRemoveQueryOptions = {
    force?: boolean;
};
declare class VolumeHandle extends Handle {
    constructor(modem: Modem, name: string);
    protected inspectResult(): Promise<ModemDialResult>;
    inspect(): Promise<Volume>;
    remove(queryOptions?: VolumeRemoveQueryOptions): Promise<void>;
    protected shouldThrowStackError(): boolean;
    static isPartOfStack(volume: Volume): boolean;
    static fromVolume(modem: Modem, volume: Volume): VolumeHandle;
}

type ClusterVolumeId = string;
type ClusterVolumeAccesModeScope = "single" | "multi";
type ClusterVolumeAccesModeSharing = "none" | "readonly" | "onewriter" | "all";
type ClusterVolumeAvailability = "active" | "pause" | "drain";
type ClusterVolumeDataPublishStatusState = "pending-publish" | "published" | "pending-node-unpublish" | "pending-controller-unpublish";
type ClusterVolumeAccessModeBase = {
    Scope?: ClusterVolumeAccesModeScope;
    Sharing?: ClusterVolumeAccesModeSharing;
};
type ClusterVolumeAccessModeMountVolume = {
    MountVolume: object;
};
type ClusterVolumeAccessModeBlockVolume = {
    BlockVolume: object;
};
type ClusterVolumeAccessMode = ClusterVolumeAccessModeBase & XOR<ClusterVolumeAccessModeMountVolume, ClusterVolumeAccessModeBlockVolume>;
type ClusterVolumeSecret = {
    Key: string;
    Secret: string;
};
type ClusterVolumeAccessibilityRequirements = {
    Requisite: Array<object>;
    Preferred: Array<object>;
};
type ClusterVolumeCapacityRange = {
    RequiredBytes: number;
    LimitBytes: number;
};
type ClusterVolumeSpecBase = {
    Group?: string;
    AccessMode: ClusterVolumeAccessMode;
    Secrets?: Arr