lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.80.mjs

@@ -1,88 +1,4948 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
-import { c as e } from "./Package.internal.8.mjs";
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import { a as t, g as e, c as r } from "./Package.internal.8.mjs";
 
-import { o as r } from "./Package.internal.81.mjs";
+import o from "events";
 
-var n = r;
+import { m as n } from "./Package.internal.74.mjs";
 
-var o = function() {};
+import { i } from "./Package.internal.1.mjs";
 
-var t = e.Bare ? queueMicrotask : process.nextTick.bind(process);
+import s from "fs";
 
-var i = function(e) {
-    return e.setHeader && typeof e.abort === "function";
+import a from "path";
+
+import { t as u } from "./Package.internal.81.mjs";
+
+import c from "zlib";
+
+import d from "util";
+
+import { s as f } from "./Package.internal.3.mjs";
+
+import { l } from "./Package.internal.5.mjs";
+
+import { p as m, r as p, a as h, b as v, c as g, d as b } from "./Package.internal.6.mjs";
+
+import { u as S } from "./Package.internal.7.mjs";
+
+var y = {
+    exports: {}
+};
+
+y.exports;
+
+(function(t) {
+    var e = i;
+    var r = s;
+    var o = a;
+    var n = u;
+    var d = c;
+    var f = [];
+    var l = f.forEach;
+    var m = f.slice;
+    t.exports.extend = function(t) {
+        l.call(m.call(arguments, 1), function(e) {
+            if (e) {
+                for (var r in e) {
+                    t[r] = e[r];
+                }
+            }
+        });
+        return t;
+    };
+    t.exports.processArgs = function(e, r, o) {
+        if (!r && typeof e === "function") {
+            r = e;
+            e = null;
+        }
+        return {
+            callback: r,
+            opts: t.exports.extend({}, o, e)
+        };
+    };
+    t.exports.parseRepositoryTag = function(t) {
+        var e;
+        var r = t.indexOf("@");
+        var o = t.lastIndexOf(":");
+        if (r >= 0) {
+            e = r;
+        } else if (o >= 0) {
+            e = o;
+        } else {
+            return {
+                repository: t
+            };
+        }
+        var n = t.slice(e + 1);
+        if (n.indexOf("/") === -1) {
+            return {
+                repository: t.slice(0, e),
+                tag: n
+            };
+        }
+        return {
+            repository: t
+        };
+    };
+    t.exports.prepareBuildContext = function(t, i) {
+        if (t && t.context) {
+            r.readFile(o.join(t.context, ".dockerignore"), (r, o) => {
+                let s;
+                let a;
+                if (!r) {
+                    const t = e({
+                        ignorecase: false
+                    }).add(o.toString());
+                    a = t.createFilter();
+                    s = t => !a(t);
+                }
+                const u = t.src.slice() || [];
+                const c = n.pack(t.context, {
+                    entries: a ? u.filter(a) : u,
+                    ignore: s
+                });
+                i(c.pipe(d.createGzip()));
+            });
+        } else {
+            i(t);
+        }
+    };
+})(y);
+
+var k = y.exports;
+
+var w = k;
+
+var P = function(t, e) {
+    this.modem = t;
+    this.id = e;
+};
+
+P.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+P.prototype.start = function(t, e) {
+    var r = this;
+    var o = w.processArgs(t, e);
+    var n = {
+        path: "/exec/" + this.id + "/start",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        isStream: true,
+        allowEmpty: true,
+        hijack: o.opts.hijack,
+        openStdin: o.opts.stdin,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "no such exec",
+            409: "container stopped/paused",
+            500: "container not running"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return o.callback(t, e);
+            o.callback(t, e);
+        });
+    }
+};
+
+P.prototype.resize = function(t, e) {
+    var r = this;
+    var o = w.processArgs(t, e);
+    var n = {
+        path: "/exec/" + this.id + "/resize?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such exec",
+            500: "container not running"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return o.callback(t, e);
+            o.callback(t, e);
+        });
+    }
+};
+
+P.prototype.inspect = function(t, e) {
+    var r = this;
+    var o = w.processArgs(t, e);
+    var n = {
+        path: "/exec/" + this.id + "/json",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such exec",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return o.callback(t, e);
+            o.callback(t, e);
+        });
+    }
+};
+
+var A = P;
+
+k.extend;
+
+var T = A, C = k;
+
+var O = function(t, e) {
+    this.modem = t;
+    this.id = e;
+    this.defaultOptions = {
+        top: {},
+        start: {},
+        commit: {},
+        stop: {},
+        pause: {},
+        unpause: {},
+        restart: {},
+        resize: {},
+        attach: {},
+        remove: {},
+        copy: {},
+        kill: {},
+        exec: {},
+        rename: {},
+        log: {},
+        stats: {},
+        getArchive: {},
+        infoArchive: {},
+        putArchive: {},
+        update: {},
+        wait: {}
+    };
+};
+
+O.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+O.prototype.inspect = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e);
+    var n = {
+        path: "/containers/" + this.id + "/json?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such container",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.rename = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.rename);
+    var n = {
+        path: "/containers/" + this.id + "/rename?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.update = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.update);
+    var n = {
+        path: "/containers/" + this.id + "/update",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            400: "bad parameter",
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.top = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.top);
+    var n = {
+        path: "/containers/" + this.id + "/top?",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.changes = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e);
+    var n = {
+        path: "/containers/" + this.id + "/changes",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such container",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.listCheckpoint = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e);
+    var n = {
+        path: "/containers/" + this.id + "/checkpoints?",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.deleteCheckpoint = function(t, e, r) {
+    var o = this;
+    var n = C.processArgs(e, r);
+    var i = {
+        path: "/containers/" + this.id + "/checkpoints/" + t + "?",
+        method: "DELETE",
+        abortSignal: n.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: n.opts
+    };
+    if (n.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(i, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(i, function(t, e) {
+            n.callback(t, e);
+        });
+    }
+};
+
+O.prototype.createCheckpoint = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e);
+    var n = {
+        path: "/containers/" + this.id + "/checkpoints",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        allowEmpty: true,
+        statusCodes: {
+            200: true,
+            201: true,
+            204: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.export = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e);
+    var n = {
+        path: "/containers/" + this.id + "/export",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        isStream: true,
+        statusCodes: {
+            200: true,
+            404: "no such container",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.start = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.start);
+    var n = {
+        path: "/containers/" + this.id + "/start?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            304: "container already started",
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.pause = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.pause);
+    var n = {
+        path: "/containers/" + this.id + "/pause",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.unpause = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.unpause);
+    var n = {
+        path: "/containers/" + this.id + "/unpause",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.exec = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.exec);
+    var n = {
+        path: "/containers/" + this.id + "/exec",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            404: "no such container",
+            409: "container stopped/paused",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(o, n) {
+                if (o) {
+                    return e(o);
+                }
+                t(new T(r.modem, n.Id));
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return o.callback(t, e);
+            o.callback(t, new T(r.modem, e.Id));
+        });
+    }
+};
+
+O.prototype.commit = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.commit);
+    o.opts.container = this.id;
+    var n = {
+        path: "/commit?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.stop = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.stop);
+    var n = {
+        path: "/containers/" + this.id + "/stop?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            304: "container already stopped",
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.restart = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.restart);
+    var n = {
+        path: "/containers/" + this.id + "/restart?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.kill = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.kill);
+    var n = {
+        path: "/containers/" + this.id + "/kill?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.resize = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.resize);
+    var n = {
+        path: "/containers/" + this.id + "/resize?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.attach = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.attach);
+    var n = {
+        path: "/containers/" + this.id + "/attach?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        isStream: true,
+        hijack: o.opts.hijack,
+        openStdin: o.opts.stdin,
+        statusCodes: {
+            200: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.wait = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.wait);
+    var n = {
+        path: "/containers/" + this.id + "/wait?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.remove = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.remove);
+    var n = {
+        path: "/containers/" + this.id + "?",
+        method: "DELETE",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            400: "bad parameter",
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.copy = function(t, e) {
+    var r = this;
+    console.log("container.copy is deprecated since Docker v1.8.x");
+    var o = C.processArgs(t, e, this.defaultOptions.copy);
+    var n = {
+        path: "/containers/" + this.id + "/copy",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        isStream: true,
+        statusCodes: {
+            200: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.getArchive = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.getArchive);
+    var n = {
+        path: "/containers/" + this.id + "/archive?",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        isStream: true,
+        statusCodes: {
+            200: true,
+            400: "client error, bad parameters",
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.infoArchive = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.infoArchive);
+    var n = {
+        path: "/containers/" + this.id + "/archive?",
+        method: "HEAD",
+        abortSignal: o.opts.abortSignal,
+        isStream: true,
+        statusCodes: {
+            200: true,
+            400: "client error, bad parameters",
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.putArchive = function(t, e, r) {
+    var o = this;
+    var n = C.processArgs(e, r, this.defaultOptions.putArchive);
+    var i = {
+        path: "/containers/" + this.id + "/archive?",
+        method: "PUT",
+        file: t,
+        abortSignal: n.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "client error, bad parameters",
+            403: "client error, permission denied",
+            404: "no such container",
+            500: "server error"
+        },
+        options: n.opts
+    };
+    if (n.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(i, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(i, function(t, e) {
+            n.callback(t, e);
+        });
+    }
+};
+
+O.prototype.logs = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.log);
+    var n = {
+        path: "/containers/" + this.id + "/logs?",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        isStream: o.opts.follow || false,
+        statusCodes: {
+            200: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+O.prototype.stats = function(t, e) {
+    var r = this;
+    var o = C.processArgs(t, e, this.defaultOptions.stats);
+    var n = true;
+    if (o.opts.stream === false) {
+        n = false;
+    }
+    var i = {
+        path: "/containers/" + this.id + "/stats?",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        isStream: n,
+        statusCodes: {
+            200: true,
+            404: "no such container",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(i, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(i, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+var E = O;
+
+var D = k;
+
+var I = function(t, e) {
+    this.modem = t;
+    this.name = e;
+};
+
+I.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+I.prototype.inspect = function(t, e) {
+    var r = D.processArgs(t, e);
+    var o = this;
+    var t = {
+        path: "/images/" + this.name + "/json",
+        method: "GET",
+        options: r.opts,
+        statusCodes: {
+            200: true,
+            404: "no such image",
+            500: "server error"
+        }
+    };
+    if (r.callback === undefined) {
+        return new this.modem.Promise(function(e, r) {
+            o.modem.dial(t, function(t, o) {
+                if (t) {
+                    return r(t);
+                }
+                e(o);
+            });
+        });
+    } else {
+        this.modem.dial(t, function(t, e) {
+            if (t) return r.callback(t, e);
+            r.callback(t, e);
+        });
+    }
+};
+
+I.prototype.distribution = function(t, e) {
+    var r = D.processArgs(t, e);
+    var o = this;
+    var n = {
+        path: "/distribution/" + this.name + "/json",
+        method: "GET",
+        statusCodes: {
+            200: true,
+            401: "no such image",
+            500: "server error"
+        },
+        authconfig: r.opts ? r.opts.authconfig : undefined
+    };
+    if (r.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return r.callback(t, e);
+            r.callback(t, e);
+        });
+    }
+};
+
+I.prototype.history = function(t) {
+    var e = this;
+    var r = {
+        path: "/images/" + this.name + "/history",
+        method: "GET",
+        statusCodes: {
+            200: true,
+            404: "no such image",
+            500: "server error"
+        }
+    };
+    if (t === undefined) {
+        return new this.modem.Promise(function(t, o) {
+            e.modem.dial(r, function(e, r) {
+                if (e) {
+                    return o(e);
+                }
+                t(r);
+            });
+        });
+    } else {
+        this.modem.dial(r, function(e, r) {
+            if (e) return t(e, r);
+            t(e, r);
+        });
+    }
+};
+
+I.prototype.get = function(t) {
+    var e = this;
+    var r = {
+        path: "/images/" + this.name + "/get",
+        method: "GET",
+        isStream: true,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (t === undefined) {
+        return new this.modem.Promise(function(t, o) {
+            e.modem.dial(r, function(e, r) {
+                if (e) {
+                    return o(e);
+                }
+                t(r);
+            });
+        });
+    } else {
+        this.modem.dial(r, function(e, r) {
+            if (e) return t(e, r);
+            t(e, r);
+        });
+    }
+};
+
+I.prototype.push = function(t, e, r) {
+    var o = this;
+    var n = D.processArgs(t, e);
+    var i = true;
+    if (n.opts.stream === false) {
+        i = false;
+    }
+    var s = {
+        path: "/images/" + this.name + "/push?",
+        method: "POST",
+        options: n.opts,
+        authconfig: n.opts.authconfig || r,
+        abortSignal: n.opts.abortSignal,
+        isStream: i,
+        statusCodes: {
+            200: true,
+            404: "no such image",
+            500: "server error"
+        }
+    };
+    delete s.options.authconfig;
+    if (e === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(s, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(s, function(t, r) {
+            e(t, r);
+        });
+    }
+};
+
+I.prototype.tag = function(t, e) {
+    var r = this;
+    var o = {
+        path: "/images/" + this.name + "/tag?",
+        method: "POST",
+        options: t,
+        abortSignal: t && t.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            400: "bad parameter",
+            404: "no such image",
+            409: "conflict",
+            500: "server error"
+        }
+    };
+    if (e === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(o, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(o, function(t, r) {
+            e(t, r);
+        });
+    }
+};
+
+I.prototype.remove = function(t, e) {
+    var r = this;
+    var o = D.processArgs(t, e);
+    var n = {
+        path: "/images/" + this.name + "?",
+        method: "DELETE",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such image",
+            409: "conflict",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+var j = I;
+
+var G = k;
+
+var x = function(t, e) {
+    this.modem = t;
+    this.name = e;
+};
+
+x.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+x.prototype.inspect = function(t, e) {
+    var r = this;
+    var o = G.processArgs(t, e);
+    var n = {
+        path: "/volumes/" + this.name,
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such volume",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+x.prototype.remove = function(t, e) {
+    var r = this;
+    var o = G.processArgs(t, e);
+    var n = {
+        path: "/volumes/" + this.name,
+        method: "DELETE",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            204: true,
+            404: "no such volume",
+            409: "conflict",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+var U = x;
+
+var N = k;
+
+var R = function(t, e) {
+    this.modem = t;
+    this.id = e;
+};
+
+R.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+R.prototype.inspect = function(t, e) {
+    var r = this;
+    var o = N.processArgs(t, e);
+    var t = {
+        path: "/networks/" + this.id + "?",
+        method: "GET",
+        statusCodes: {
+            200: true,
+            404: "no such network",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(e, o) {
+            r.modem.dial(t, function(t, r) {
+                if (t) {
+                    return o(t);
+                }
+                e(r);
+            });
+        });
+    } else {
+        this.modem.dial(t, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+R.prototype.remove = function(t, e) {
+    var r = this;
+    var o = N.processArgs(t, e);
+    var n = {
+        path: "/networks/" + this.id,
+        method: "DELETE",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "no such network",
+            409: "conflict",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+R.prototype.connect = function(t, e) {
+    var r = this;
+    var o = N.processArgs(t, e);
+    var n = {
+        path: "/networks/" + this.id + "/connect",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            404: "network or container is not found",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+R.prototype.disconnect = function(t, e) {
+    var r = this;
+    var o = N.processArgs(t, e);
+    var n = {
+        path: "/networks/" + this.id + "/disconnect",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            404: "network or container is not found",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+var _ = R;
+
+var q = k;
+
+var F = function(t, e) {
+    this.modem = t;
+    this.id = e;
+};
+
+F.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+F.prototype.inspect = function(t, e) {
+    var r = this;
+    var o = q.processArgs(t, e);
+    var n = {
+        path: "/services/" + this.id,
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such service",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+F.prototype.remove = function(t, e) {
+    var r = this;
+    var o = q.processArgs(t, e);
+    var n = {
+        path: "/services/" + this.id,
+        method: "DELETE",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "no such service",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+F.prototype.update = function(t, e, r) {
+    var o = this;
+    if (!r) {
+        var n = typeof e;
+        if (n === "function") {
+            r = e;
+            e = t;
+            t = e.authconfig || undefined;
+        } else if (n === "undefined") {
+            e = t;
+            t = e.authconfig || undefined;
+        }
+    }
+    var i = {
+        path: "/services/" + this.id + "/update?",
+        method: "POST",
+        abortSignal: e && e.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such service",
+            500: "server error"
+        },
+        authconfig: t,
+        options: e
+    };
+    if (r === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(i, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(i, function(t, e) {
+            r(t, e);
+        });
+    }
+};
+
+F.prototype.logs = function(t, e) {
+    var r = this;
+    var o = q.processArgs(t, e, {});
+    var n = {
+        path: "/services/" + this.id + "/logs?",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        isStream: o.opts.follow || false,
+        statusCodes: {
+            200: true,
+            404: "no such service",
+            500: "server error",
+            503: "node is not part of a swarm"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+var V = F;
+
+var L = k;
+
+var z = function(t, e, r) {
+    this.modem = t;
+    this.name = e;
+    this.remote = r || e;
+};
+
+z.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+z.prototype.inspect = function(t, e) {
+    var r = this;
+    var o = L.processArgs(t, e);
+    var n = {
+        path: "/plugins/" + this.name + "/json",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "plugin is not installed",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+z.prototype.remove = function(t, e) {
+    var r = this;
+    var o = L.processArgs(t, e);
+    var n = {
+        path: "/plugins/" + this.name + "?",
+        method: "DELETE",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "plugin is not installed",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return o.callback(t, e);
+            o.callback(t, e);
+        });
+    }
+};
+
+z.prototype.privileges = function(t, e) {
+    var r = this;
+    var o = L.processArgs(t, e);
+    var n = {
+        path: "/plugins/privileges?",
+        method: "GET",
+        options: {
+            remote: this.remote
+        },
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+z.prototype.pull = function(t, e) {
+    var r = this;
+    var o = L.processArgs(t, e);
+    if (o.opts._query && !o.opts._query.name) {
+        o.opts._query.name = this.name;
+    }
+    if (o.opts._query && !o.opts._query.remote) {
+        o.opts._query.remote = this.remote;
+    }
+    var n = {
+        path: "/plugins/pull?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        isStream: true,
+        options: o.opts,
+        statusCodes: {
+            200: true,
+            204: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+z.prototype.enable = function(t, e) {
+    var r = this;
+    var o = L.processArgs(t, e);
+    var n = {
+        path: "/plugins/" + this.name + "/enable?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+z.prototype.disable = function(t, e) {
+    var r = this;
+    var o = L.processArgs(t, e);
+    var n = {
+        path: "/plugins/" + this.name + "/disable",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+z.prototype.push = function(t, e) {
+    var r = this;
+    var o = L.processArgs(t, e);
+    var n = {
+        path: "/plugins/" + this.name + "/push",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "plugin not installed",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+z.prototype.configure = function(t, e) {
+    var r = this;
+    var o = L.processArgs(t, e);
+    var n = {
+        path: "/plugins/" + this.name + "/set",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "plugin not installed",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+z.prototype.upgrade = function(t, e, r) {
+    var o = this;
+    if (!r && typeof e === "function") {
+        r = e;
+        e = t;
+        t = e.authconfig || undefined;
+    }
+    var n = {
+        path: "/plugins/" + this.name + "/upgrade?",
+        method: "POST",
+        abortSignal: e && e.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "plugin not installed",
+            500: "server error"
+        },
+        authconfig: t,
+        options: e
+    };
+    if (r === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            r(t, e);
+        });
+    }
+};
+
+var M = z;
+
+var W = k;
+
+var B = function(t, e) {
+    this.modem = t;
+    this.id = e;
+};
+
+B.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+B.prototype.inspect = function(t, e) {
+    var r = this;
+    var o = W.processArgs(t, e);
+    var n = {
+        path: "/secrets/" + this.id,
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "secret not found",
+            406: "node is not part of a swarm",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+B.prototype.update = function(t, e) {
+    var r = this;
+    if (!e && typeof t === "function") {
+        e = t;
+    }
+    var o = {
+        path: "/secrets/" + this.id + "/update?",
+        method: "POST",
+        abortSignal: t && t.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "secret not found",
+            500: "server error"
+        },
+        options: t
+    };
+    if (e === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(o, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(o, function(t, r) {
+            e(t, r);
+        });
+    }
+};
+
+B.prototype.remove = function(t, e) {
+    var r = this;
+    var o = W.processArgs(t, e);
+    var n = {
+        path: "/secrets/" + this.id,
+        method: "DELETE",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "secret not found",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+var H = B;
+
+var J = k;
+
+var $ = function(t, e) {
+    this.modem = t;
+    this.id = e;
+};
+
+$.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+$.prototype.inspect = function(t, e) {
+    var r = this;
+    var o = J.processArgs(t, e);
+    var n = {
+        path: "/configs/" + this.id,
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "config not found",
+            500: "server error",
+            503: "node is not part of a swarm"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+$.prototype.update = function(t, e) {
+    var r = this;
+    var o = J.processArgs(t, e);
+    var n = {
+        path: "/configs/" + this.id + "/update?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "config not found",
+            500: "server error",
+            503: "node is not part of a swarm"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+$.prototype.remove = function(t, e) {
+    var r = this;
+    var o = J.processArgs(t, e);
+    var n = {
+        path: "/configs/" + this.id,
+        method: "DELETE",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            404: "config not found",
+            500: "server error",
+            503: "node is not part of a swarm"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+var K = $;
+
+var X = k;
+
+var Y = function(t, e) {
+    this.modem = t;
+    this.id = e;
+    this.defaultOptions = {
+        log: {}
+    };
+};
+
+Y.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+Y.prototype.inspect = function(t, e) {
+    var r = this;
+    var o = X.processArgs(t, e);
+    var n = {
+        path: "/tasks/" + this.id,
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "unknown task",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+Y.prototype.logs = function(t, e) {
+    var r = this;
+    var o = X.processArgs(t, e, this.defaultOptions.log);
+    var n = {
+        path: "/tasks/" + this.id + "/logs?",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        isStream: o.opts.follow || false,
+        statusCodes: {
+            101: true,
+            200: true,
+            404: "no such container",
+            500: "server error",
+            503: "node is not part of a swarm"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+var Q = Y;
+
+var Z = k;
+
+var tt = function(t, e) {
+    this.modem = t;
+    this.id = e;
+};
+
+tt.prototype[d.inspect.custom] = function() {
+    return this;
+};
+
+tt.prototype.inspect = function(t, e) {
+    var r = this;
+    var o = Z.processArgs(t, e);
+    var n = {
+        path: "/nodes/" + this.id,
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such node",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+tt.prototype.update = function(t, e) {
+    var r = this;
+    if (!e && typeof t === "function") {
+        e = t;
+    }
+    var o = {
+        path: "/nodes/" + this.id + "/update?",
+        method: "POST",
+        abortSignal: t && t.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such node",
+            406: "node is not part of a swarm",
+            500: "server error"
+        },
+        options: t
+    };
+    if (e === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(o, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(o, function(t, r) {
+            e(t, r);
+        });
+    }
+};
+
+tt.prototype.remove = function(t, e) {
+    var r = this;
+    var o = Z.processArgs(t, e);
+    var n = {
+        path: "/nodes/" + this.id + "?",
+        method: "DELETE",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            404: "no such node",
+            500: "server error"
+        },
+        options: o.opts
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+var et = tt;
+
+var rt = {};
+
+var ot = {};
+
+Object.defineProperty(ot, "__esModule", {
+    value: true
+});
+
+ot.addCommonProtos = ot.loadProtosWithOptionsSync = ot.loadProtosWithOptions = void 0;
+
+const nt = s;
+
+const it = a;
+
+const st = m;
+
+function at(t, e) {
+    const r = t.resolvePath;
+    t.resolvePath = (t, o) => {
+        if (it.isAbsolute(o)) {
+            return o;
+        }
+        for (const t of e) {
+            const e = it.join(t, o);
+            try {
+                nt.accessSync(e, nt.constants.R_OK);
+                return e;
+            } catch (t) {
+                continue;
+            }
+        }
+        process.emitWarning(`${o} not found in any of the include paths ${e}`);
+        return r(t, o);
+    };
+}
+
+async function ut(t, e) {
+    const r = new st.Root;
+    e = e || {};
+    if (!!e.includeDirs) {
+        if (!Array.isArray(e.includeDirs)) {
+            return Promise.reject(new Error("The includeDirs option must be an array"));
+        }
+        at(r, e.includeDirs);
+    }
+    const o = await r.load(t, e);
+    o.resolveAll();
+    return o;
+}
+
+ot.loadProtosWithOptions = ut;
+
+function ct(t, e) {
+    const r = new st.Root;
+    e = e || {};
+    if (!!e.includeDirs) {
+        if (!Array.isArray(e.includeDirs)) {
+            throw new Error("The includeDirs option must be an array");
+        }
+        at(r, e.includeDirs);
+    }
+    const o = r.loadSync(t, e);
+    o.resolveAll();
+    return o;
+}
+
+ot.loadProtosWithOptionsSync = ct;
+
+function dt() {
+    const t = p;
+    const e = h;
+    const r = v;
+    const o = g;
+    st.common("api", t.nested.google.nested.protobuf.nested);
+    st.common("descriptor", e.nested.google.nested.protobuf.nested);
+    st.common("source_context", r.nested.google.nested.protobuf.nested);
+    st.common("type", o.nested.google.nested.protobuf.nested);
+}
+
+ot.addCommonProtos = dt;
+
+(function(t) {
+    Object.defineProperty(t, "__esModule", {
+        value: true
+    });
+    t.loadFileDescriptorSetFromObject = t.loadFileDescriptorSetFromBuffer = t.fromJSON = t.loadSync = t.load = t.IdempotencyLevel = t.isAnyExtension = t.Long = void 0;
+    const e = l;
+    const r = m;
+    const o = b;
+    const n = ot;
+    const i = S;
+    t.Long = i;
+    function s(t) {
+        return "@type" in t && typeof t["@type"] === "string";
+    }
+    t.isAnyExtension = s;
+    var a;
+    (function(t) {
+        t["IDEMPOTENCY_UNKNOWN"] = "IDEMPOTENCY_UNKNOWN";
+        t["NO_SIDE_EFFECTS"] = "NO_SIDE_EFFECTS";
+        t["IDEMPOTENT"] = "IDEMPOTENT";
+    })(a = t.IdempotencyLevel || (t.IdempotencyLevel = {}));
+    const u = {
+        longs: String,
+        enums: String,
+        bytes: String,
+        defaults: true,
+        oneofs: true,
+        json: true
+    };
+    function c(t, e) {
+        if (t === "") {
+            return e;
+        } else {
+            return t + "." + e;
+        }
+    }
+    function d(t) {
+        return t instanceof r.Service || t instanceof r.Type || t instanceof r.Enum;
+    }
+    function f(t) {
+        return t instanceof r.Namespace || t instanceof r.Root;
+    }
+    function p(t, e) {
+        const r = c(e, t.name);
+        if (d(t)) {
+            return [ [ r, t ] ];
+        } else {
+            if (f(t) && typeof t.nested !== "undefined") {
+                return Object.keys(t.nested).map(e => p(t.nested[e], r)).reduce((t, e) => t.concat(e), []);
+            }
+        }
+        return [];
+    }
+    function h(t, e) {
+        return function r(o) {
+            return t.toObject(t.decode(o), e);
+        };
+    }
+    function v(t) {
+        return function e(r) {
+            if (Array.isArray(r)) {
+                throw new Error(`Failed to serialize message: expected object with ${t.name} structure, got array instead`);
+            }
+            const o = t.fromObject(r);
+            return t.encode(o).finish();
+        };
+    }
+    function g(t) {
+        return (t || []).reduce((t, e) => {
+            for (const [r, o] of Object.entries(e)) {
+                switch (r) {
+                  case "uninterpreted_option":
+                    t.uninterpreted_option.push(e.uninterpreted_option);
+                    break;
+
+                  default:
+                    t[r] = o;
+                }
+            }
+            return t;
+        }, {
+            deprecated: false,
+            idempotency_level: a.IDEMPOTENCY_UNKNOWN,
+            uninterpreted_option: []
+        });
+    }
+    function y(t, r, o, n) {
+        const i = t.resolvedRequestType;
+        const s = t.resolvedResponseType;
+        return {
+            path: "/" + r + "/" + t.name,
+            requestStream: !!t.requestStream,
+            responseStream: !!t.responseStream,
+            requestSerialize: v(i),
+            requestDeserialize: h(i, o),
+            responseSerialize: v(s),
+            responseDeserialize: h(s, o),
+            originalName: e(t.name),
+            requestType: w(i, n),
+            responseType: w(s, n),
+            options: g(t.parsedOptions)
+        };
+    }
+    function k(t, e, r, o) {
+        const n = {};
+        for (const i of t.methodsArray) {
+            n[i.name] = y(i, e, r, o);
+        }
+        return n;
+    }
+    function w(t, e) {
+        const r = t.toDescriptor("proto3");
+        return {
+            format: "Protocol Buffer 3 DescriptorProto",
+            type: r.$type.toObject(r, u),
+            fileDescriptorProtos: e
+        };
+    }
+    function P(t, e) {
+        const r = t.toDescriptor("proto3");
+        return {
+            format: "Protocol Buffer 3 EnumDescriptorProto",
+            type: r.$type.toObject(r, u),
+            fileDescriptorProtos: e
+        };
+    }
+    function A(t, e, o, n) {
+        if (t instanceof r.Service) {
+            return k(t, e, o, n);
+        } else if (t instanceof r.Type) {
+            return w(t, n);
+        } else if (t instanceof r.Enum) {
+            return P(t, n);
+        } else {
+            throw new Error("Type mismatch in reflection object handling");
+        }
+    }
+    function T(t, e) {
+        const r = {};
+        t.resolveAll();
+        const n = t.toDescriptor("proto3").file;
+        const i = n.map(t => Buffer.from(o.FileDescriptorProto.encode(t).finish()));
+        for (const [o, n] of p(t, "")) {
+            r[o] = A(n, o, e, i);
+        }
+        return r;
+    }
+    function C(t, e) {
+        e = e || {};
+        const o = r.Root.fromDescriptor(t);
+        o.resolveAll();
+        return T(o, e);
+    }
+    function O(t, e) {
+        return (0, n.loadProtosWithOptions)(t, e).then(t => T(t, e));
+    }
+    t.load = O;
+    function E(t, e) {
+        const r = (0, n.loadProtosWithOptionsSync)(t, e);
+        return T(r, e);
+    }
+    t.loadSync = E;
+    function D(t, e) {
+        e = e || {};
+        const o = r.Root.fromJSON(t);
+        o.resolveAll();
+        return T(o, e);
+    }
+    t.fromJSON = D;
+    function I(t, e) {
+        const r = o.FileDescriptorSet.decode(t);
+        return C(r, e);
+    }
+    t.loadFileDescriptorSetFromBuffer = I;
+    function j(t, e) {
+        const r = o.FileDescriptorSet.fromObject(t);
+        return C(r, e);
+    }
+    t.loadFileDescriptorSetFromObject = j;
+    (0, n.addCommonProtos)();
+})(rt);
+
+const ft = "ffffffff-ffff-ffff-ffff-ffffffffffff";
+
+const lt = "00000000-0000-0000-0000-000000000000";
+
+const mt = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+
+function pt(t) {
+    return typeof t === "string" && mt.test(t);
+}
+
+function ht(t) {
+    if (!pt(t)) {
+        throw TypeError("Invalid UUID");
+    }
+    var e;
+    var r = new Uint8Array(16);
+    r[0] = (e = parseInt(t.slice(0, 8), 16)) >>> 24;
+    r[1] = e >>> 16 & 255;
+    r[2] = e >>> 8 & 255;
+    r[3] = e & 255;
+    r[4] = (e = parseInt(t.slice(9, 13), 16)) >>> 8;
+    r[5] = e & 255;
+    r[6] = (e = parseInt(t.slice(14, 18), 16)) >>> 8;
+    r[7] = e & 255;
+    r[8] = (e = parseInt(t.slice(19, 23), 16)) >>> 8;
+    r[9] = e & 255;
+    r[10] = (e = parseInt(t.slice(24, 36), 16)) / 1099511627776 & 255;
+    r[11] = e / 4294967296 & 255;
+    r[12] = e >>> 24 & 255;
+    r[13] = e >>> 16 & 255;
+    r[14] = e >>> 8 & 255;
+    r[15] = e & 255;
+    return r;
+}
+
+var vt = [];
+
+for (var gt = 0; gt < 256; ++gt) {
+    vt.push((gt + 256).toString(16).slice(1));
+}
+
+function bt(t, e = 0) {
+    return (vt[t[e + 0]] + vt[t[e + 1]] + vt[t[e + 2]] + vt[t[e + 3]] + "-" + vt[t[e + 4]] + vt[t[e + 5]] + "-" + vt[t[e + 6]] + vt[t[e + 7]] + "-" + vt[t[e + 8]] + vt[t[e + 9]] + "-" + vt[t[e + 10]] + vt[t[e + 11]] + vt[t[e + 12]] + vt[t[e + 13]] + vt[t[e + 14]] + vt[t[e + 15]]).toLowerCase();
+}
+
+function St(t, e = 0) {
+    var r = bt(t, e);
+    if (!pt(r)) {
+        throw TypeError("Stringified UUID is invalid");
+    }
+    return r;
+}
+
+var yt;
+
+var kt = new Uint8Array(16);
+
+function wt() {
+    if (!yt) {
+        yt = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+        if (!yt) {
+            throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+        }
+    }
+    return yt(kt);
+}
+
+var Pt;
+
+var At;
+
+var Tt = 0;
+
+var Ct = 0;
+
+function Ot(t, e, r) {
+    var o = e && r || 0;
+    var n = e || new Array(16);
+    t = t || {};
+    var i = t.node;
+    var s = t.clockseq;
+    if (!t._v6) {
+        if (!i) {
+            i = Pt;
+        }
+        if (s == null) {
+            s = At;
+        }
+    }
+    if (i == null || s == null) {
+        var a = t.random || (t.rng || wt)();
+        if (i == null) {
+            i = [ a[0], a[1], a[2], a[3], a[4], a[5] ];
+            if (!Pt && !t._v6) {
+                i[0] |= 1;
+                Pt = i;
+            }
+        }
+        if (s == null) {
+            s = (a[6] << 8 | a[7]) & 16383;
+            if (At === undefined && !t._v6) {
+                At = s;
+            }
+        }
+    }
+    var u = t.msecs !== undefined ? t.msecs : Date.now();
+    var c = t.nsecs !== undefined ? t.nsecs : Ct + 1;
+    var d = u - Tt + (c - Ct) / 1e4;
+    if (d < 0 && t.clockseq === undefined) {
+        s = s + 1 & 16383;
+    }
+    if ((d < 0 || u > Tt) && t.nsecs === undefined) {
+        c = 0;
+    }
+    if (c >= 1e4) {
+        throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
+    }
+    Tt = u;
+    Ct = c;
+    At = s;
+    u += 122192928e5;
+    var f = ((u & 268435455) * 1e4 + c) % 4294967296;
+    n[o++] = f >>> 24 & 255;
+    n[o++] = f >>> 16 & 255;
+    n[o++] = f >>> 8 & 255;
+    n[o++] = f & 255;
+    var l = u / 4294967296 * 1e4 & 268435455;
+    n[o++] = l >>> 8 & 255;
+    n[o++] = l & 255;
+    n[o++] = l >>> 24 & 15 | 16;
+    n[o++] = l >>> 16 & 255;
+    n[o++] = s >>> 8 | 128;
+    n[o++] = s & 255;
+    for (var m = 0; m < 6; ++m) {
+        n[o + m] = i[m];
+    }
+    return e || bt(n);
+}
+
+function Et(t) {
+    var e = typeof t === "string" ? ht(t) : t;
+    var r = Dt(e);
+    return typeof t === "string" ? bt(r) : r;
+}
+
+function Dt(t, e = false) {
+    return Uint8Array.of((t[6] & 15) << 4 | t[7] >> 4 & 15, (t[7] & 15) << 4 | (t[4] & 240) >> 4, (t[4] & 15) << 4 | (t[5] & 240) >> 4, (t[5] & 15) << 4 | (t[0] & 240) >> 4, (t[0] & 15) << 4 | (t[1] & 240) >> 4, (t[1] & 15) << 4 | (t[2] & 240) >> 4, 96 | t[2] & 15, t[3], t[8], t[9], t[10], t[11], t[12], t[13], t[14], t[15]);
+}
+
+function It(t) {
+    t = unescape(encodeURIComponent(t));
+    var e = [];
+    for (var r = 0; r < t.length; ++r) {
+        e.push(t.charCodeAt(r));
+    }
+    return e;
+}
+
+var jt = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+
+var Gt = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+
+function xt(t, e, r) {
+    function o(t, o, n, i) {
+        var s;
+        if (typeof t === "string") {
+            t = It(t);
+        }
+        if (typeof o === "string") {
+            o = ht(o);
+        }
+        if (((s = o) === null || s === void 0 ? void 0 : s.length) !== 16) {
+            throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
+        }
+        var a = new Uint8Array(16 + t.length);
+        a.set(o);
+        a.set(t, o.length);
+        a = r(a);
+        a[6] = a[6] & 15 | e;
+        a[8] = a[8] & 63 | 128;
+        if (n) {
+            i = i || 0;
+            for (var u = 0; u < 16; ++u) {
+                n[i + u] = a[u];
+            }
+            return n;
+        }
+        return bt(a);
+    }
+    try {
+        o.name = t;
+    } catch (t) {}
+    o.DNS = jt;
+    o.URL = Gt;
+    return o;
+}
+
+function Ut(t) {
+    if (typeof t === "string") {
+        var e = unescape(encodeURIComponent(t));
+        t = new Uint8Array(e.length);
+        for (var r = 0; r < e.length; ++r) {
+            t[r] = e.charCodeAt(r);
+        }
+    }
+    return Nt(_t(qt(t), t.length * 8));
+}
+
+function Nt(t) {
+    var e = [];
+    var r = t.length * 32;
+    var o = "0123456789abcdef";
+    for (var n = 0; n < r; n += 8) {
+        var i = t[n >> 5] >>> n % 32 & 255;
+        var s = parseInt(o.charAt(i >>> 4 & 15) + o.charAt(i & 15), 16);
+        e.push(s);
+    }
+    return e;
+}
+
+function Rt(t) {
+    return (t + 64 >>> 9 << 4) + 14 + 1;
+}
+
+function _t(t, e) {
+    t[e >> 5] |= 128 << e % 32;
+    t[Rt(e) - 1] = e;
+    var r = 1732584193;
+    var o = -271733879;
+    var n = -1732584194;
+    var i = 271733878;
+    for (var s = 0; s < t.length; s += 16) {
+        var a = r;
+        var u = o;
+        var c = n;
+        var d = i;
+        r = zt(r, o, n, i, t[s], 7, -680876936);
+        i = zt(i, r, o, n, t[s + 1], 12, -389564586);
+        n = zt(n, i, r, o, t[s + 2], 17, 606105819);
+        o = zt(o, n, i, r, t[s + 3], 22, -1044525330);
+        r = zt(r, o, n, i, t[s + 4], 7, -176418897);
+        i = zt(i, r, o, n, t[s + 5], 12, 1200080426);
+        n = zt(n, i, r, o, t[s + 6], 17, -1473231341);
+        o = zt(o, n, i, r, t[s + 7], 22, -45705983);
+        r = zt(r, o, n, i, t[s + 8], 7, 1770035416);
+        i = zt(i, r, o, n, t[s + 9], 12, -1958414417);
+        n = zt(n, i, r, o, t[s + 10], 17, -42063);
+        o = zt(o, n, i, r, t[s + 11], 22, -1990404162);
+        r = zt(r, o, n, i, t[s + 12], 7, 1804603682);
+        i = zt(i, r, o, n, t[s + 13], 12, -40341101);
+        n = zt(n, i, r, o, t[s + 14], 17, -1502002290);
+        o = zt(o, n, i, r, t[s + 15], 22, 1236535329);
+        r = Mt(r, o, n, i, t[s + 1], 5, -165796510);
+        i = Mt(i, r, o, n, t[s + 6], 9, -1069501632);
+        n = Mt(n, i, r, o, t[s + 11], 14, 643717713);
+        o = Mt(o, n, i, r, t[s], 20, -373897302);
+        r = Mt(r, o, n, i, t[s + 5], 5, -701558691);
+        i = Mt(i, r, o, n, t[s + 10], 9, 38016083);
+        n = Mt(n, i, r, o, t[s + 15], 14, -660478335);
+        o = Mt(o, n, i, r, t[s + 4], 20, -405537848);
+        r = Mt(r, o, n, i, t[s + 9], 5, 568446438);
+        i = Mt(i, r, o, n, t[s + 14], 9, -1019803690);
+        n = Mt(n, i, r, o, t[s + 3], 14, -187363961);
+        o = Mt(o, n, i, r, t[s + 8], 20, 1163531501);
+        r = Mt(r, o, n, i, t[s + 13], 5, -1444681467);
+        i = Mt(i, r, o, n, t[s + 2], 9, -51403784);
+        n = Mt(n, i, r, o, t[s + 7], 14, 1735328473);
+        o = Mt(o, n, i, r, t[s + 12], 20, -1926607734);
+        r = Wt(r, o, n, i, t[s + 5], 4, -378558);
+        i = Wt(i, r, o, n, t[s + 8], 11, -2022574463);
+        n = Wt(n, i, r, o, t[s + 11], 16, 1839030562);
+        o = Wt(o, n, i, r, t[s + 14], 23, -35309556);
+        r = Wt(r, o, n, i, t[s + 1], 4, -1530992060);
+        i = Wt(i, r, o, n, t[s + 4], 11, 1272893353);
+        n = Wt(n, i, r, o, t[s + 7], 16, -155497632);
+        o = Wt(o, n, i, r, t[s + 10], 23, -1094730640);
+        r = Wt(r, o, n, i, t[s + 13], 4, 681279174);
+        i = Wt(i, r, o, n, t[s], 11, -358537222);
+        n = Wt(n, i, r, o, t[s + 3], 16, -722521979);
+        o = Wt(o, n, i, r, t[s + 6], 23, 76029189);
+        r = Wt(r, o, n, i, t[s + 9], 4, -640364487);
+        i = Wt(i, r, o, n, t[s + 12], 11, -421815835);
+        n = Wt(n, i, r, o, t[s + 15], 16, 530742520);
+        o = Wt(o, n, i, r, t[s + 2], 23, -995338651);
+        r = Bt(r, o, n, i, t[s], 6, -198630844);
+        i = Bt(i, r, o, n, t[s + 7], 10, 1126891415);
+        n = Bt(n, i, r, o, t[s + 14], 15, -1416354905);
+        o = Bt(o, n, i, r, t[s + 5], 21, -57434055);
+        r = Bt(r, o, n, i, t[s + 12], 6, 1700485571);
+        i = Bt(i, r, o, n, t[s + 3], 10, -1894986606);
+        n = Bt(n, i, r, o, t[s + 10], 15, -1051523);
+        o = Bt(o, n, i, r, t[s + 1], 21, -2054922799);
+        r = Bt(r, o, n, i, t[s + 8], 6, 1873313359);
+        i = Bt(i, r, o, n, t[s + 15], 10, -30611744);
+        n = Bt(n, i, r, o, t[s + 6], 15, -1560198380);
+        o = Bt(o, n, i, r, t[s + 13], 21, 1309151649);
+        r = Bt(r, o, n, i, t[s + 4], 6, -145523070);
+        i = Bt(i, r, o, n, t[s + 11], 10, -1120210379);
+        n = Bt(n, i, r, o, t[s + 2], 15, 718787259);
+        o = Bt(o, n, i, r, t[s + 9], 21, -343485551);
+        r = Ft(r, a);
+        o = Ft(o, u);
+        n = Ft(n, c);
+        i = Ft(i, d);
+    }
+    return [ r, o, n, i ];
+}
+
+function qt(t) {
+    if (t.length === 0) {
+        return [];
+    }
+    var e = t.length * 8;
+    var r = new Uint32Array(Rt(e));
+    for (var o = 0; o < e; o += 8) {
+        r[o >> 5] |= (t[o / 8] & 255) << o % 32;
+    }
+    return r;
+}
+
+function Ft(t, e) {
+    var r = (t & 65535) + (e & 65535);
+    var o = (t >> 16) + (e >> 16) + (r >> 16);
+    return o << 16 | r & 65535;
+}
+
+function Vt(t, e) {
+    return t << e | t >>> 32 - e;
+}
+
+function Lt(t, e, r, o, n, i) {
+    return Ft(Vt(Ft(Ft(e, t), Ft(o, i)), n), r);
+}
+
+function zt(t, e, r, o, n, i, s) {
+    return Lt(e & r | ~e & o, t, e, n, i, s);
+}
+
+function Mt(t, e, r, o, n, i, s) {
+    return Lt(e & o | r & ~o, t, e, n, i, s);
+}
+
+function Wt(t, e, r, o, n, i, s) {
+    return Lt(e ^ r ^ o, t, e, n, i, s);
+}
+
+function Bt(t, e, r, o, n, i, s) {
+    return Lt(r ^ (e | ~o), t, e, n, i, s);
+}
+
+var Ht = xt("v3", 48, Ut);
+
+const Jt = Ht;
+
+var $t = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+
+const Kt = {
+    randomUUID: $t
+};
+
+function Xt(t, e, r) {
+    if (Kt.randomUUID && !e && !t) {
+        return Kt.randomUUID();
+    }
+    t = t || {};
+    var o = t.random || (t.rng || wt)();
+    o[6] = o[6] & 15 | 64;
+    o[8] = o[8] & 63 | 128;
+    if (e) {
+        r = r || 0;
+        for (var n = 0; n < 16; ++n) {
+            e[r + n] = o[n];
+        }
+        return e;
+    }
+    return bt(o);
+}
+
+function Yt(t, e, r, o) {
+    switch (t) {
+      case 0:
+        return e & r ^ ~e & o;
+
+      case 1:
+        return e ^ r ^ o;
+
+      case 2:
+        return e & r ^ e & o ^ r & o;
+
+      case 3:
+        return e ^ r ^ o;
+    }
+}
+
+function Qt(t, e) {
+    return t << e | t >>> 32 - e;
+}
+
+function Zt(t) {
+    var e = [ 1518500249, 1859775393, 2400959708, 3395469782 ];
+    var r = [ 1732584193, 4023233417, 2562383102, 271733878, 3285377520 ];
+    if (typeof t === "string") {
+        var o = unescape(encodeURIComponent(t));
+        t = [];
+        for (var n = 0; n < o.length; ++n) {
+            t.push(o.charCodeAt(n));
+        }
+    } else if (!Array.isArray(t)) {
+        t = Array.prototype.slice.call(t);
+    }
+    t.push(128);
+    var i = t.length / 4 + 2;
+    var s = Math.ceil(i / 16);
+    var a = new Array(s);
+    for (var u = 0; u < s; ++u) {
+        var c = new Uint32Array(16);
+        for (var d = 0; d < 16; ++d) {
+            c[d] = t[u * 64 + d * 4] << 24 | t[u * 64 + d * 4 + 1] << 16 | t[u * 64 + d * 4 + 2] << 8 | t[u * 64 + d * 4 + 3];
+        }
+        a[u] = c;
+    }
+    a[s - 1][14] = (t.length - 1) * 8 / Math.pow(2, 32);
+    a[s - 1][14] = Math.floor(a[s - 1][14]);
+    a[s - 1][15] = (t.length - 1) * 8 & 4294967295;
+    for (var f = 0; f < s; ++f) {
+        var l = new Uint32Array(80);
+        for (var m = 0; m < 16; ++m) {
+            l[m] = a[f][m];
+        }
+        for (var p = 16; p < 80; ++p) {
+            l[p] = Qt(l[p - 3] ^ l[p - 8] ^ l[p - 14] ^ l[p - 16], 1);
+        }
+        var h = r[0];
+        var v = r[1];
+        var g = r[2];
+        var b = r[3];
+        var S = r[4];
+        for (var y = 0; y < 80; ++y) {
+            var k = Math.floor(y / 20);
+            var w = Qt(h, 5) + Yt(k, v, g, b) + S + e[k] + l[y] >>> 0;
+            S = b;
+            b = g;
+            g = Qt(v, 30) >>> 0;
+            v = h;
+            h = w;
+        }
+        r[0] = r[0] + h >>> 0;
+        r[1] = r[1] + v >>> 0;
+        r[2] = r[2] + g >>> 0;
+        r[3] = r[3] + b >>> 0;
+        r[4] = r[4] + S >>> 0;
+    }
+    return [ r[0] >> 24 & 255, r[0] >> 16 & 255, r[0] >> 8 & 255, r[0] & 255, r[1] >> 24 & 255, r[1] >> 16 & 255, r[1] >> 8 & 255, r[1] & 255, r[2] >> 24 & 255, r[2] >> 16 & 255, r[2] >> 8 & 255, r[2] & 255, r[3] >> 24 & 255, r[3] >> 16 & 255, r[3] >> 8 & 255, r[3] & 255, r[4] >> 24 & 255, r[4] >> 16 & 255, r[4] >> 8 & 255, r[4] & 255 ];
+}
+
+var te = xt("v5", 80, Zt);
+
+const ee = te;
+
+function re(t, e) {
+    var r = Object.keys(t);
+    if (Object.getOwnPropertySymbols) {
+        var o = Object.getOwnPropertySymbols(t);
+        e && (o = o.filter(function(e) {
+            return Object.getOwnPropertyDescriptor(t, e).enumerable;
+        })), r.push.apply(r, o);
+    }
+    return r;
+}
+
+function oe(t) {
+    for (var e = 1; e < arguments.length; e++) {
+        var r = null != arguments[e] ? arguments[e] : {};
+        e % 2 ? re(Object(r), true).forEach(function(e) {
+            ne(t, e, r[e]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(r)) : re(Object(r)).forEach(function(e) {
+            Object.defineProperty(t, e, Object.getOwnPropertyDescriptor(r, e));
+        });
+    }
+    return t;
+}
+
+function ne(t, e, r) {
+    return (e = ie(e)) in t ? Object.defineProperty(t, e, {
+        value: r,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    }) : t[e] = r, t;
+}
+
+function ie(t) {
+    var e = se(t, "string");
+    return "symbol" == typeof e ? e : e + "";
+}
+
+function se(t, e) {
+    if ("object" != typeof t || !t) return t;
+    var r = t[Symbol.toPrimitive];
+    if (void 0 !== r) {
+        var o = r.call(t, e);
+        if ("object" != typeof o) return o;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return String(t);
+}
+
+function ae(t = {}, e, r = 0) {
+    var o = Ot(oe(oe({}, t), {}, {
+        _v6: true
+    }), new Uint8Array(16));
+    o = Et(o);
+    if (e) {
+        for (var n = 0; n < 16; n++) {
+            e[r + n] = o[n];
+        }
+        return e;
+    }
+    return bt(o);
+}
+
+function ue(t) {
+    var e = typeof t === "string" ? ht(t) : t;
+    var r = ce(e);
+    return typeof t === "string" ? bt(r) : r;
+}
+
+function ce(t) {
+    return Uint8Array.of((t[3] & 15) << 4 | t[4] >> 4 & 15, (t[4] & 15) << 4 | (t[5] & 240) >> 4, (t[5] & 15) << 4 | t[6] & 15, t[7], (t[1] & 15) << 4 | (t[2] & 240) >> 4, (t[2] & 15) << 4 | (t[3] & 240) >> 4, 16 | (t[0] & 240) >> 4, (t[0] & 15) << 4 | (t[1] & 240) >> 4, t[8], t[9], t[10], t[11], t[12], t[13], t[14], t[15]);
+}
+
+var de = null;
+
+var fe = null;
+
+var le = 0;
+
+function me(t, e, r) {
+    t = t || {};
+    var o = e && r || 0;
+    var n = e || new Uint8Array(16);
+    var i = t.random || (t.rng || wt)();
+    var s = t.msecs !== undefined ? t.msecs : Date.now();
+    var a = t.seq !== undefined ? t.seq : null;
+    var u = fe;
+    var c = de;
+    if (s > le && t.msecs === undefined) {
+        le = s;
+        if (a !== null) {
+            u = null;
+            c = null;
+        }
+    }
+    if (a !== null) {
+        if (a > 2147483647) {
+            a = 2147483647;
+        }
+        u = a >>> 19 & 4095;
+        c = a & 524287;
+    }
+    if (u === null || c === null) {
+        u = i[6] & 127;
+        u = u << 8 | i[7];
+        c = i[8] & 63;
+        c = c << 8 | i[9];
+        c = c << 5 | i[10] >>> 3;
+    }
+    if (s + 1e4 > le && a === null) {
+        if (++c > 524287) {
+            c = 0;
+            if (++u > 4095) {
+                u = 0;
+                le++;
+            }
+        }
+    } else {
+        le = s;
+    }
+    fe = u;
+    de = c;
+    n[o++] = le / 1099511627776 & 255;
+    n[o++] = le / 4294967296 & 255;
+    n[o++] = le / 16777216 & 255;
+    n[o++] = le / 65536 & 255;
+    n[o++] = le / 256 & 255;
+    n[o++] = le & 255;
+    n[o++] = u >>> 4 & 15 | 112;
+    n[o++] = u & 255;
+    n[o++] = c >>> 13 & 63 | 128;
+    n[o++] = c >>> 5 & 255;
+    n[o++] = c << 3 & 255 | i[10] & 7;
+    n[o++] = i[11];
+    n[o++] = i[12];
+    n[o++] = i[13];
+    n[o++] = i[14];
+    n[o++] = i[15];
+    return e || bt(n);
+}
+
+function pe(t) {
+    if (!pt(t)) {
+        throw TypeError("Invalid UUID");
+    }
+    return parseInt(t.slice(14, 15), 16);
+}
+
+const he = Object.freeze(Object.defineProperty({
+    __proto__: null,
+    MAX: ft,
+    NIL: lt,
+    parse: ht,
+    stringify: St,
+    v1: Ot,
+    v1ToV6: Et,
+    v3: Jt,
+    v4: Xt,
+    v5: ee,
+    v6: ae,
+    v6ToV1: ue,
+    v7: me,
+    validate: pt,
+    version: pe
+}, Symbol.toStringTag, {
+    value: "Module"
+}));
+
+const ve = t(he);
+
+var ge = f, be = rt, Se = ve.v4;
+
+function ye(t, e, r) {
+    const o = Se();
+    const n = {
+        method: "POST",
+        path: "/session",
+        hijack: true,
+        headers: {
+            Upgrade: "h2c",
+            "X-Docker-Expose-Session-Uuid": o,
+            "X-Docker-Expose-Session-Name": "testcontainers"
+        },
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    t.modem.dial(n, function(t, n) {
+        if (t) {
+            return r(t, null, () => undefined);
+        }
+        const i = new ge.Server;
+        const s = ge.ServerCredentials.createInsecure();
+        const a = i.createConnectionInjector(s);
+        a.injectConnection(n);
+        const u = be.fromJSON({
+            nested: {
+                moby: {
+                    nested: {
+                        filesync: {
+                            nested: {
+                                v1: {
+                                    options: {
+                                        go_package: "auth"
+                                    },
+                                    nested: {
+                                        Auth: {
+                                            methods: {
+                                                Credentials: {
+                                                    requestType: "CredentialsRequest",
+                                                    responseType: "CredentialsResponse"
+                                                },
+                                                FetchToken: {
+                                                    requestType: "FetchTokenRequest",
+                                                    responseType: "FetchTokenResponse"
+                                                },
+                                                GetTokenAuthority: {
+                                                    requestType: "GetTokenAuthorityRequest",
+                                                    responseType: "GetTokenAuthorityResponse"
+                                                },
+                                                VerifyTokenAuthority: {
+                                                    requestType: "VerifyTokenAuthorityRequest",
+                                                    responseType: "VerifyTokenAuthorityResponse"
+                                                }
+                                            }
+                                        },
+                                        CredentialsRequest: {
+                                            fields: {
+                                                Host: {
+                                                    type: "string",
+                                                    id: 1
+                                                }
+                                            }
+                                        },
+                                        CredentialsResponse: {
+                                            fields: {
+                                                Username: {
+                                                    type: "string",
+                                                    id: 1
+                                                },
+                                                Secret: {
+                                                    type: "string",
+                                                    id: 2
+                                                }
+                                            }
+                                        },
+                                        FetchTokenRequest: {
+                                            fields: {
+                                                ClientID: {
+                                                    type: "string",
+                                                    id: 1
+                                                },
+                                                Host: {
+                                                    type: "string",
+                                                    id: 2
+                                                },
+                                                Realm: {
+                                                    type: "string",
+                                                    id: 3
+                                                },
+                                                Service: {
+                                                    type: "string",
+                                                    id: 4
+                                                },
+                                                Scopes: {
+                                                    rule: "repeated",
+                                                    type: "string",
+                                                    id: 5
+                                                }
+                                            }
+                                        },
+                                        FetchTokenResponse: {
+                                            fields: {
+                                                Token: {
+                                                    type: "string",
+                                                    id: 1
+                                                },
+                                                ExpiresIn: {
+                                                    type: "int64",
+                                                    id: 2
+                                                },
+                                                IssuedAt: {
+                                                    type: "int64",
+                                                    id: 3
+                                                }
+                                            }
+                                        },
+                                        GetTokenAuthorityRequest: {
+                                            fields: {
+                                                Host: {
+                                                    type: "string",
+                                                    id: 1
+                                                },
+                                                Salt: {
+                                                    type: "bytes",
+                                                    id: 2
+                                                }
+                                            }
+                                        },
+                                        GetTokenAuthorityResponse: {
+                                            fields: {
+                                                PublicKey: {
+                                                    type: "bytes",
+                                                    id: 1
+                                                }
+                                            }
+                                        },
+                                        VerifyTokenAuthorityRequest: {
+                                            fields: {
+                                                Host: {
+                                                    type: "string",
+                                                    id: 1
+                                                },
+                                                Payload: {
+                                                    type: "bytes",
+                                                    id: 2
+                                                },
+                                                Salt: {
+                                                    type: "bytes",
+                                                    id: 3
+                                                }
+                                            }
+                                        },
+                                        VerifyTokenAuthorityResponse: {
+                                            fields: {
+                                                Signed: {
+                                                    type: "bytes",
+                                                    id: 1
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        const c = ge.loadPackageDefinition(u);
+        i.addService(c.moby.filesync.v1.Auth.service, {
+            Credentials({request: t}, r) {
+                if (e) {
+                    r(null, {
+                        Username: e.username,
+                        Secret: e.password
+                    });
+                } else {
+                    r(null, {});
+                }
+            }
+        });
+        function d() {
+            i.forceShutdown();
+            n.end();
+        }
+        r(null, o, d);
+    });
+}
+
+var ke = ye;
+
+var we = o.EventEmitter, Pe = n, Ae = E, Te = j, Ce = U, Oe = _, Ee = V, De = M, Ie = H, je = K, Ge = Q, xe = et, Ue = A, Ne = k, Re = ke, _e = Ne.extend;
+
+var qe = function(t) {
+    if (!(this instanceof qe)) return new qe(t);
+    var e = r.Promise;
+    if (t && t.Promise) {
+        e = t.Promise;
+        if (Object.keys(t).length === 1) {
+            t = undefined;
+        }
+    }
+    if (t && t.modem) {
+        this.modem = t.modem;
+    } else {
+        this.modem = new Pe(t);
+    }
+    this.modem.Promise = e;
+};
+
+qe.prototype.createContainer = function(t, e) {
+    var r = this;
+    var o = {
+        path: "/containers/create?",
+        method: "POST",
+        options: t,
+        authconfig: t.authconfig,
+        abortSignal: t.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            400: "bad parameter",
+            404: "no such container",
+            406: "impossible to attach",
+            500: "server error"
+        }
+    };
+    delete t.authconfig;
+    if (e === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(o, function(o, n) {
+                if (o) {
+                    return e(o);
+                }
+                t(r.getContainer(n.Id));
+            });
+        });
+    } else {
+        this.modem.dial(o, function(t, o) {
+            if (t) return e(t, o);
+            e(t, r.getContainer(o.Id));
+        });
+    }
+};
+
+qe.prototype.createImage = function(t, e, r) {
+    var o = this;
+    if (!r && typeof e === "function") {
+        r = e;
+        e = t;
+        t = e.authconfig || undefined;
+    } else if (!r && !e) {
+        e = t;
+        t = e.authconfig;
+    }
+    var n = {
+        path: "/images/create?",
+        method: "POST",
+        options: e,
+        authconfig: t,
+        abortSignal: e.abortSignal,
+        isStream: true,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (r === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            r(t, e);
+        });
+    }
+};
+
+qe.prototype.loadImage = function(t, e, r) {
+    var o = this;
+    if (!r && typeof e === "function") {
+        r = e;
+        e = null;
+    }
+    var n = {
+        path: "/images/load?",
+        method: "POST",
+        options: e,
+        file: t,
+        abortSignal: e && e.abortSignal,
+        isStream: true,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (r === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            r(t, e);
+        });
+    }
+};
+
+qe.prototype.importImage = function(t, e, r) {
+    var o = this;
+    if (!r && typeof e === "function") {
+        r = e;
+        e = undefined;
+    }
+    if (!e) e = {};
+    e.fromSrc = "-";
+    var n = {
+        path: "/images/create?",
+        method: "POST",
+        options: e,
+        file: t,
+        abortSignal: e.abortSignal,
+        isStream: true,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (r === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            r(t, e);
+        });
+    }
+};
+
+qe.prototype.checkAuth = function(t, e) {
+    var r = this;
+    var o = {
+        path: "/auth",
+        method: "POST",
+        options: t,
+        abortSignal: t.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            500: "server error"
+        }
+    };
+    if (e === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(o, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(o, function(t, r) {
+            e(t, r);
+        });
+    }
+};
+
+qe.prototype.buildImage = function(t, e, r) {
+    var o = this;
+    if (!r && typeof e === "function") {
+        r = e;
+        e = null;
+    }
+    var n = {
+        path: "/build?",
+        method: "POST",
+        file: undefined,
+        options: e,
+        abortSignal: e && e.abortSignal,
+        isStream: true,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (e) {
+        if (e.registryconfig) {
+            n.registryconfig = n.options.registryconfig;
+            delete n.options.registryconfig;
+        }
+        if (e.authconfig) {
+            n.authconfig = n.options.authconfig;
+            delete n.options.authconfig;
+        }
+        if (e.cachefrom && Array.isArray(e.cachefrom)) {
+            n.options.cachefrom = JSON.stringify(e.cachefrom);
+        }
+    }
+    function i(e) {
+        Ne.prepareBuildContext(t, t => {
+            n.file = t;
+            o.modem.dial(n, e);
+        });
+    }
+    function s(t) {
+        if (e?.version === "2") {
+            Re(o, n.authconfig, (e, r, o) => {
+                if (e) {
+                    return t(e);
+                }
+                n.options.session = r;
+                i((e, r) => {
+                    t(e, r);
+                    if (r) {
+                        r.on("end", o);
+                    }
+                });
+            });
+        } else {
+            i(t);
+        }
+    }
+    if (r === undefined) {
+        return new o.modem.Promise(function(t, e) {
+            s(function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        s(r);
+    }
+};
+
+qe.prototype.getContainer = function(t) {
+    return new Ae(this.modem, t);
+};
+
+qe.prototype.getImage = function(t) {
+    return new Te(this.modem, t);
+};
+
+qe.prototype.getVolume = function(t) {
+    return new Ce(this.modem, t);
+};
+
+qe.prototype.getPlugin = function(t, e) {
+    return new De(this.modem, t, e);
+};
+
+qe.prototype.getService = function(t) {
+    return new Ee(this.modem, t);
+};
+
+qe.prototype.getTask = function(t) {
+    return new Ge(this.modem, t);
+};
+
+qe.prototype.getNode = function(t) {
+    return new xe(this.modem, t);
+};
+
+qe.prototype.getNetwork = function(t) {
+    return new Oe(this.modem, t);
+};
+
+qe.prototype.getSecret = function(t) {
+    return new Ie(this.modem, t);
+};
+
+qe.prototype.getConfig = function(t) {
+    return new je(this.modem, t);
+};
+
+qe.prototype.getExec = function(t) {
+    return new Ue(this.modem, t);
+};
+
+qe.prototype.listContainers = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/containers/json?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.listImages = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/images/json?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.getImages = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/images/get?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        isStream: true,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.listServices = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/services?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.listNodes = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/nodes?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            404: "no such node",
+            500: "server error",
+            503: "node is not part of a swarm"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.listTasks = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/tasks?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.createSecret = function(t, e) {
+    var r = Ne.processArgs(t, e);
+    var o = this;
+    var n = {
+        path: "/secrets/create?",
+        method: "POST",
+        options: r.opts,
+        abortSignal: r.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            406: "server error or node is not part of a swarm",
+            409: "name conflicts with an existing object",
+            500: "server error"
+        }
+    };
+    if (r.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(n, function(r, n) {
+                if (r) {
+                    return e(r);
+                }
+                t(o.getSecret(n.ID));
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return r.callback(t, e);
+            r.callback(t, o.getSecret(e.ID));
+        });
+    }
+};
+
+qe.prototype.createConfig = function(t, e) {
+    var r = Ne.processArgs(t, e);
+    var o = this;
+    var n = {
+        path: "/configs/create?",
+        method: "POST",
+        options: r.opts,
+        abortSignal: r.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            406: "server error or node is not part of a swarm",
+            409: "name conflicts with an existing object",
+            500: "server error"
+        }
+    };
+    if (r.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(n, function(r, n) {
+                if (r) {
+                    return e(r);
+                }
+                t(o.getConfig(n.ID));
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return r.callback(t, e);
+            r.callback(t, o.getConfig(e.ID));
+        });
+    }
+};
+
+qe.prototype.listSecrets = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/secrets?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.listConfigs = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/configs?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.createPlugin = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/plugins/create?",
+        method: "POST",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            204: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(n, i) {
+                if (n) {
+                    return e(n);
+                }
+                t(r.getPlugin(o.opts.name));
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return o.callback(t, e);
+            o.callback(t, r.getPlugin(o.opts.name));
+        });
+    }
+};
+
+qe.prototype.listPlugins = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/plugins?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.pruneImages = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/images/prune?",
+        method: "POST",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.pruneBuilder = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/build/prune",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.pruneContainers = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/containers/prune?",
+        method: "POST",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.pruneVolumes = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/volumes/prune?",
+        method: "POST",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.pruneNetworks = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/networks/prune?",
+        method: "POST",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.createVolume = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/volumes/create?",
+        method: "POST",
+        allowEmpty: true,
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(o, n) {
+                if (o) {
+                    return e(o);
+                }
+                t(r.getVolume(n.Name));
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return o.callback(t, e);
+            o.callback(t, r.getVolume(e.Name));
+        });
+    }
+};
+
+qe.prototype.createService = function(t, e, r) {
+    if (!r && typeof e === "function") {
+        r = e;
+        e = t;
+        t = e.authconfig || undefined;
+    } else if (!e && !r) {
+        e = t;
+    }
+    var o = this;
+    var n = {
+        path: "/services/create",
+        method: "POST",
+        options: e,
+        authconfig: t,
+        abortSignal: e && e.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            500: "server error"
+        }
+    };
+    if (r === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            o.modem.dial(n, function(r, n) {
+                if (r) {
+                    return e(r);
+                }
+                t(o.getService(n.ID || n.Id));
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return r(t, e);
+            r(t, o.getService(e.ID || e.Id));
+        });
+    }
+};
+
+qe.prototype.listVolumes = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/volumes?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.createNetwork = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/networks/create?",
+        method: "POST",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            201: true,
+            404: "driver not found",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(o, n) {
+                if (o) {
+                    return e(o);
+                }
+                t(r.getNetwork(n.Id));
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            if (t) return o.callback(t, e);
+            o.callback(t, r.getNetwork(e.Id));
+        });
+    }
+};
+
+qe.prototype.listNetworks = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/networks?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.searchImages = function(t, e) {
+    var r = this;
+    var o = {
+        path: "/images/search?",
+        method: "GET",
+        options: t,
+        authconfig: t.authconfig,
+        abortSignal: t.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (e === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(o, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(o, function(t, r) {
+            e(t, r);
+        });
+    }
+};
+
+qe.prototype.info = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var t = {
+        path: "/info",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(e, o) {
+            r.modem.dial(t, function(t, r) {
+                if (t) {
+                    return o(t);
+                }
+                e(r);
+            });
+        });
+    } else {
+        this.modem.dial(t, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.version = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var t = {
+        path: "/version",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(e, o) {
+            r.modem.dial(t, function(t, r) {
+                if (t) {
+                    return o(t);
+                }
+                e(r);
+            });
+        });
+    } else {
+        this.modem.dial(t, function(t, e) {
+            o.callback(t, e);
+        });
+    }
 };
 
-var a = function(e) {
-    return e.stdio && Array.isArray(e.stdio) && e.stdio.length === 3;
+qe.prototype.ping = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/_ping",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
+    };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
 };
 
-var s = function(e, r, l) {
-    if (typeof r === "function") return s(e, null, r);
-    if (!r) r = {};
-    l = n(l || o);
-    var f = e._writableState;
-    var c = e._readableState;
-    var u = r.readable || r.readable !== false && e.readable;
-    var v = r.writable || r.writable !== false && e.writable;
-    var d = false;
-    var m = function() {
-        if (!e.writable) b();
+qe.prototype.df = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/system/df",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
     };
-    var b = function() {
-        v = false;
-        if (!u) l.call(e);
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.getEvents = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/events?",
+        method: "GET",
+        options: o.opts,
+        abortSignal: o.opts.abortSignal,
+        isStream: true,
+        statusCodes: {
+            200: true,
+            500: "server error"
+        }
     };
-    var p = function() {
-        u = false;
-        if (!v) l.call(e);
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.pull = function(t, e, r, o) {
+    var n = Ne.processArgs(e, r);
+    var i = Ne.parseRepositoryTag(t);
+    n.opts.fromImage = i.repository;
+    n.opts.tag = i.tag || "latest";
+    var s = [ n.opts, n.callback ];
+    if (o) {
+        s = [ o, n.opts, n.callback ];
+    }
+    return this.createImage.apply(this, s);
+};
+
+qe.prototype.pullAll = function(t, e, r, o) {
+    var n = Ne.processArgs(e, r);
+    var i = Ne.parseRepositoryTag(t);
+    n.opts.fromImage = i.repository;
+    var s = [ n.opts, n.callback ];
+    if (o) {
+        s = [ o, n.opts, n.callback ];
+    }
+    return this.createImage.apply(this, s);
+};
+
+qe.prototype.run = function(t, e, r, o, n, i) {
+    if (typeof arguments[arguments.length - 1] === "function") {
+        return this.runCallback(t, e, r, o, n, i);
+    } else {
+        return this.runPromise(t, e, r, o, n);
+    }
+};
+
+qe.prototype.runCallback = function(t, e, r, o, n, i) {
+    if (!i && typeof o === "function") {
+        i = o;
+        o = {};
+        n = {};
+    } else if (!i && typeof n === "function") {
+        i = n;
+        n = {};
+    }
+    var s = new we;
+    function a(t, e) {
+        if (t) return i(t, null, e);
+        s.emit("container", e);
+        e.attach({
+            stream: true,
+            stdout: true,
+            stderr: true
+        }, function t(o, a) {
+            if (o) return i(o, null, e);
+            s.emit("stream", a);
+            if (r) {
+                if (r instanceof Array) {
+                    a.on("end", function() {
+                        try {
+                            r[0].end();
+                        } catch (t) {}
+                        try {
+                            r[1].end();
+                        } catch (t) {}
+                    });
+                    e.modem.demuxStream(a, r[0], r[1]);
+                } else {
+                    a.setEncoding("utf8");
+                    a.pipe(r, {
+                        end: true
+                    });
+                }
+            }
+            e.start(n, function(t, r) {
+                if (t) return i(t, r, e);
+                s.emit("start", e);
+                e.wait(function(t, r) {
+                    s.emit("data", r);
+                    i(t, r, e);
+                });
+            });
+        });
+    }
+    var u = {
+        Hostname: "",
+        User: "",
+        AttachStdin: false,
+        AttachStdout: true,
+        AttachStderr: true,
+        Tty: true,
+        OpenStdin: false,
+        StdinOnce: false,
+        Env: null,
+        Cmd: e,
+        Image: t,
+        Volumes: {},
+        VolumesFrom: []
     };
-    var L = function(r) {
-        l.call(e, r ? new Error("exited with error code: " + r) : null);
+    _e(u, o);
+    this.createContainer(u, a);
+    return s;
+};
+
+qe.prototype.runPromise = function(t, e, r, o, n) {
+    var i = this;
+    o = o || {};
+    n = n || {};
+    var s = {
+        Hostname: "",
+        User: "",
+        AttachStdin: false,
+        AttachStdout: true,
+        AttachStderr: true,
+        Tty: true,
+        OpenStdin: false,
+        StdinOnce: false,
+        Env: null,
+        Cmd: e,
+        Image: t,
+        Volumes: {},
+        VolumesFrom: []
     };
-    var w = function(r) {
-        l.call(e, r);
+    _e(s, o);
+    var a;
+    return new this.modem.Promise(function(t, e) {
+        i.createContainer(s).then(function(t) {
+            a = t;
+            return t.attach({
+                stream: true,
+                stdout: true,
+                stderr: true
+            });
+        }).then(function(t) {
+            if (r) {
+                if (r instanceof Array) {
+                    t.on("end", function() {
+                        try {
+                            r[0].end();
+                        } catch (t) {}
+                        try {
+                            r[1].end();
+                        } catch (t) {}
+                    });
+                    a.modem.demuxStream(t, r[0], r[1]);
+                } else {
+                    t.setEncoding("utf8");
+                    t.pipe(r, {
+                        end: true
+                    });
+                }
+            }
+            return a.start(n);
+        }).then(function(t) {
+            return a.wait();
+        }).then(function(e) {
+            t([ e, a ]);
+        }).catch(function(t) {
+            e(t);
+        });
+    });
+};
+
+qe.prototype.swarmInit = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/swarm/init",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            406: "node is already part of a Swarm"
+        },
+        options: o.opts
     };
-    var q = function() {
-        t(h);
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.swarmJoin = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/swarm/join",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            406: "node is already part of a Swarm"
+        },
+        options: o.opts
     };
-    var h = function() {
-        if (d) return;
-        if (u && !(c && (c.ended && !c.destroyed))) return l.call(e, new Error("premature close"));
-        if (v && !(f && (f.ended && !f.destroyed))) return l.call(e, new Error("premature close"));
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.swarmLeave = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/swarm/leave?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            406: "node is not part of a Swarm"
+        },
+        options: o.opts
     };
-    var y = function() {
-        e.req.on("finish", b);
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
+};
+
+qe.prototype.swarmUpdate = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/swarm/update?",
+        method: "POST",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            400: "bad parameter",
+            406: "node is already part of a Swarm"
+        },
+        options: o.opts
     };
-    if (i(e)) {
-        e.on("complete", b);
-        e.on("abort", q);
-        if (e.req) y(); else e.on("request", y);
-    } else if (v && !f) {
-        e.on("end", m);
-        e.on("close", m);
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
     }
-    if (a(e)) e.on("exit", L);
-    e.on("end", p);
-    e.on("finish", b);
-    if (r.error !== false) e.on("error", w);
-    e.on("close", q);
-    return function() {
-        d = true;
-        e.removeListener("complete", b);
-        e.removeListener("abort", q);
-        e.removeListener("request", y);
-        if (e.req) e.req.removeListener("finish", b);
-        e.removeListener("end", m);
-        e.removeListener("close", m);
-        e.removeListener("finish", b);
-        e.removeListener("exit", L);
-        e.removeListener("end", p);
-        e.removeListener("error", w);
-        e.removeListener("close", q);
+};
+
+qe.prototype.swarmInspect = function(t, e) {
+    var r = this;
+    var o = Ne.processArgs(t, e);
+    var n = {
+        path: "/swarm",
+        method: "GET",
+        abortSignal: o.opts.abortSignal,
+        statusCodes: {
+            200: true,
+            406: "This node is not a swarm manager",
+            500: "server error"
+        }
     };
+    if (o.callback === undefined) {
+        return new this.modem.Promise(function(t, e) {
+            r.modem.dial(n, function(r, o) {
+                if (r) {
+                    return e(r);
+                }
+                t(o);
+            });
+        });
+    } else {
+        this.modem.dial(n, function(t, e) {
+            o.callback(t, e);
+        });
+    }
 };
 
-var l = s;
+qe.Container = Ae;
+
+qe.Image = Te;
+
+qe.Volume = Ce;
+
+qe.Network = Oe;
+
+qe.Service = Ee;
+
+qe.Plugin = De;
+
+qe.Secret = Ie;
+
+qe.Task = Ge;
+
+qe.Node = xe;
+
+qe.Exec = Ue;
+
+var Fe = qe;
+
+const Ve = e(Fe);
 
-export { l as e };
+export { Ve as D };