@dagger.io/dagger 0.8.7 → 0.9.0

package/dist/api/client.gen.js

@@ -85,6 +85,44 @@ export var NetworkProtocol;
      */
     NetworkProtocol["Udp"] = "UDP";
 })(NetworkProtocol || (NetworkProtocol = {}));
+/**
+ * Distinguishes the different kinds of TypeDefs.
+ */
+export var TypeDefKind;
+(function (TypeDefKind) {
+    /**
+     * A boolean value
+     */
+    TypeDefKind["Booleankind"] = "BooleanKind";
+    /**
+     * An integer value
+     */
+    TypeDefKind["Integerkind"] = "IntegerKind";
+    /**
+     * A list of values all having the same type.
+     *
+     * Always paired with a ListTypeDef.
+     */
+    TypeDefKind["Listkind"] = "ListKind";
+    /**
+     * A named type defined in the GraphQL schema, with fields and functions.
+     *
+     * Always paired with an ObjectTypeDef.
+     */
+    TypeDefKind["Objectkind"] = "ObjectKind";
+    /**
+     * A string value
+     */
+    TypeDefKind["Stringkind"] = "StringKind";
+    /**
+     * A special kind used to signify that no value is returned.
+     *
+     * This is used for functions that have no return value. The outer TypeDef
+     * specifying this Kind is always Optional, as the Void is never actually
+     * represented.
+     */
+    TypeDefKind["Voidkind"] = "VoidKind";
+})(TypeDefKind || (TypeDefKind = {}));
 /**
  * A directory whose contents persist across runs.
  */
@@ -119,37 +157,99 @@ export class Container extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _endpoint, _envVariable, _export, _hostname, _id, _imageRef, _label, _platform, _publish, _stderr, _stdout, _sync, _user, _workdir) {
+    constructor(parent, _id, _envVariable, _export, _imageRef, _label, _platform, _publish, _shellEndpoint, _stderr, _stdout, _sync, _user, _workdir) {
         super(parent);
-        this._endpoint = undefined;
+        this._id = undefined;
         this._envVariable = undefined;
         this._export = undefined;
-        this._hostname = undefined;
-        this._id = undefined;
         this._imageRef = undefined;
         this._label = undefined;
         this._platform = undefined;
         this._publish = undefined;
+        this._shellEndpoint = undefined;
         this._stderr = undefined;
         this._stdout = undefined;
         this._sync = undefined;
         this._user = undefined;
         this._workdir = undefined;
-        this._endpoint = _endpoint;
+        this._id = _id;
         this._envVariable = _envVariable;
         this._export = _export;
-        this._hostname = _hostname;
-        this._id = _id;
         this._imageRef = _imageRef;
         this._label = _label;
         this._platform = _platform;
         this._publish = _publish;
+        this._shellEndpoint = _shellEndpoint;
         this._stderr = _stderr;
         this._stdout = _stdout;
         this._sync = _sync;
         this._user = _user;
         this._workdir = _workdir;
     }
+    /**
+     * A unique identifier for this container.
+     */
+    id() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._id) {
+                return this._id;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Turn the container into a Service.
+     *
+     * Be sure to set any exposed ports before this conversion.
+     */
+    asService() {
+        return new Service({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "asService",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Returns a File representing the container serialized to a tarball.
+     * @param opts.platformVariants Identifiers for other platform specific containers.
+     * Used for multi-platform image.
+     * @param opts.forcedCompression Force each layer of the image to use the specified compression algorithm.
+     * If this is unset, then if a layer already has a compressed blob in the engine's
+     * cache, that will be used (this can result in a mix of compression algorithms for
+     * different layers). If this is unset and a layer has no compressed blob in the
+     * engine's cache, then it will be compressed using Gzip.
+     * @param opts.mediaTypes Use the specified media types for the image's layers. Defaults to OCI, which
+     * is largely compatible with most recent container runtimes, but Docker may be needed
+     * for older runtimes without OCI support.
+     */
+    asTarball(opts) {
+        const metadata = {
+            forcedCompression: { is_enum: true },
+            mediaTypes: { is_enum: true },
+        };
+        return new File({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "asTarball",
+                    args: Object.assign(Object.assign({}, opts), { __metadata: metadata }),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
     /**
      * Initializes this container from a Dockerfile build.
      * @param context Directory context used by the Dockerfile.
@@ -212,32 +312,6 @@ export class Container extends BaseClient {
             sessionToken: this.sessionToken,
         });
     }
-    /**
-     * Retrieves an endpoint that clients can use to reach this container.
-     *
-     * If no port is specified, the first exposed port is used. If none exist an error is returned.
-     *
-     * If a scheme is specified, a URL is returned. Otherwise, a host:port pair is returned.
-     *
-     * Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-     * @param opts.port The exposed port number for the endpoint
-     * @param opts.scheme Return a URL with the given scheme, eg. http for http://
-     */
-    endpoint(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._endpoint) {
-                return this._endpoint;
-            }
-            const response = yield computeQuery([
-                ...this._queryTree,
-                {
-                    operation: "endpoint",
-                    args: Object.assign({}, opts),
-                },
-            ], this.client);
-            return response;
-        });
-    }
     /**
      * Retrieves entrypoint to be prepended to the arguments of all commands.
      */
@@ -334,8 +408,6 @@ export class Container extends BaseClient {
      *
      * This includes ports already exposed by the image, even if not
      * explicitly added with dagger.
-     *
-     * Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
      */
     exposedPorts() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -393,42 +465,6 @@ export class Container extends BaseClient {
             sessionToken: this.sessionToken,
         });
     }
-    /**
-     * Retrieves a hostname which can be used by clients to reach this container.
-     *
-     * Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-     */
-    hostname() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._hostname) {
-                return this._hostname;
-            }
-            const response = yield computeQuery([
-                ...this._queryTree,
-                {
-                    operation: "hostname",
-                },
-            ], this.client);
-            return response;
-        });
-    }
-    /**
-     * A unique identifier for this container.
-     */
-    id() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._id) {
-                return this._id;
-            }
-            const response = yield computeQuery([
-                ...this._queryTree,
-                {
-                    operation: "id",
-                },
-            ], this.client);
-            return response;
-        });
-    }
     /**
      * The unique image reference which can only be retrieved immediately after the 'Container.From' call.
      */
@@ -455,7 +491,7 @@ export class Container extends BaseClient {
      * @param opts.tag Identifies the tag to import from the archive, if the archive bundles
      * multiple tags.
      */
-    import(source, opts) {
+    import_(source, opts) {
         return new Container({
             queryTree: [
                 ...this._queryTree,
@@ -610,6 +646,26 @@ export class Container extends BaseClient {
             sessionToken: this.sessionToken,
         });
     }
+    /**
+     * Return a websocket endpoint that, if connected to, will start the container with a TTY streamed
+     * over the websocket.
+     *
+     * Primarily intended for internal use with the dagger CLI.
+     */
+    shellEndpoint() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._shellEndpoint) {
+                return this._shellEndpoint;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "shellEndpoint",
+                },
+            ], this.client);
+            return response;
+        });
+    }
     /**
      * The error stream of the last executed command.
      *
@@ -797,8 +853,6 @@ export class Container extends BaseClient {
      * Exposed ports serve two purposes:
      *   - For health checks and introspection, when running services
      *   - For setting the EXPOSE OCI field when publishing the container
-     *
-     * Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
      * @param port Port number to expose
      * @param opts.protocol Transport layer network protocol
      * @param opts.description Optional port description
@@ -1090,8 +1144,6 @@ export class Container extends BaseClient {
      * The service will be reachable from the container via the provided hostname alias.
      *
      * The service dependency will also convey to any files or directories produced by the container.
-     *
-     * Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
      * @param alias A name that can be used to reach the service from the container
      * @param service Identifier of the service container
      */
@@ -1184,8 +1236,6 @@ export class Container extends BaseClient {
     }
     /**
      * Unexpose a previously exposed port.
-     *
-     * Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
      * @param port Port number to unexpose
      * @param opts.protocol Port protocol to unexpose
      */
@@ -1325,15 +1375,58 @@ export class Directory extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _export, _id, _sync) {
+    constructor(parent, _id, _export, _sync) {
         super(parent);
-        this._export = undefined;
         this._id = undefined;
+        this._export = undefined;
         this._sync = undefined;
-        this._export = _export;
         this._id = _id;
+        this._export = _export;
         this._sync = _sync;
     }
+    /**
+     * The content-addressed identifier of the directory.
+     */
+    id() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._id) {
+                return this._id;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Load the directory as a Dagger module
+     * @param opts.sourceSubpath An optional subpath of the directory which contains the module's source
+     * code.
+     *
+     * This is needed when the module code is in a subdirectory but requires
+     * parent directories to be loaded in order to execute. For example, the
+     * module source code may need a go.mod, project.toml, package.json, etc. file
+     * from a parent directory.
+     *
+     * If not set, the module source code is loaded from the root of the
+     * directory.
+     */
+    asModule(opts) {
+        return new Module_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "asModule",
+                    args: Object.assign({}, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
     /**
      * Gets the difference between this directory and an another directory.
      * @param other Identifier of the directory to compare.
@@ -1445,23 +1538,6 @@ export class Directory extends BaseClient {
             sessionToken: this.sessionToken,
         });
     }
-    /**
-     * The content-addressed identifier of the directory.
-     */
-    id() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._id) {
-                return this._id;
-            }
-            const response = yield computeQuery([
-                ...this._queryTree,
-                {
-                    operation: "id",
-                },
-            ], this.client);
-            return response;
-        });
-    }
     /**
      * Creates a named sub-pipeline
      * @param name Pipeline name.
@@ -1689,79 +1765,145 @@ export class EnvVariable extends BaseClient {
     }
 }
 /**
- * A file.
+ * A definition of a field on a custom object defined in a Module.
+ * A field on an object has a static value, as opposed to a function on an
+ * object whose value is computed by invoking code (and can accept arguments).
  */
-export class File extends BaseClient {
+export class FieldTypeDef extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _contents, _export, _id, _size, _sync) {
+    constructor(parent, _description, _name) {
         super(parent);
-        this._contents = undefined;
-        this._export = undefined;
-        this._id = undefined;
-        this._size = undefined;
-        this._sync = undefined;
-        this._contents = _contents;
-        this._export = _export;
-        this._id = _id;
-        this._size = _size;
-        this._sync = _sync;
+        this._description = undefined;
+        this._name = undefined;
+        this._description = _description;
+        this._name = _name;
     }
     /**
-     * Retrieves the contents of the file.
+     * A doc string for the field, if any
      */
-    contents() {
+    description() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._contents) {
-                return this._contents;
+            if (this._description) {
+                return this._description;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "contents",
+                    operation: "description",
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * Writes the file to a file path on the host.
-     * @param path Location of the written directory (e.g., "output.txt").
-     * @param opts.allowParentDirPath If allowParentDirPath is true, the path argument can be a directory path, in which case
-     * the file will be created in that directory.
+     * The name of the field in the object
      */
-    export(path, opts) {
+    name() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._export) {
-                return this._export;
+            if (this._name) {
+                return this._name;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "export",
-                    args: Object.assign({ path }, opts),
+                    operation: "name",
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * Retrieves the content-addressed identifier of the file.
+     * The type of the field
      */
-    id() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._id) {
-                return this._id;
-            }
-            const response = yield computeQuery([
+    typeDef() {
+        return new TypeDef({
+            queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "id",
+                    operation: "typeDef",
                 },
-            ], this.client);
-            return response;
-        });
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+}
+/**
+ * A file.
+ */
+export class File extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _id, _contents, _export, _size, _sync) {
+        super(parent);
+        this._id = undefined;
+        this._contents = undefined;
+        this._export = undefined;
+        this._size = undefined;
+        this._sync = undefined;
+        this._id = _id;
+        this._contents = _contents;
+        this._export = _export;
+        this._size = _size;
+        this._sync = _sync;
+    }
+    /**
+     * Retrieves the content-addressed identifier of the file.
+     */
+    id() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._id) {
+                return this._id;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Retrieves the contents of the file.
+     */
+    contents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._contents) {
+                return this._contents;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "contents",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Writes the file to a file path on the host.
+     * @param path Location of the written directory (e.g., "output.txt").
+     * @param opts.allowParentDirPath If allowParentDirPath is true, the path argument can be a directory path, in which case
+     * the file will be created in that directory.
+     */
+    export(path, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._export) {
+                return this._export;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "export",
+                    args: Object.assign({ path }, opts),
+                },
+            ], this.client);
+            return response;
+        });
     }
     /**
      * Gets the size of the file, in bytes.
@@ -1823,134 +1965,131 @@ export class File extends BaseClient {
     }
 }
 /**
- * A git ref (tag, branch or commit).
+ * Function represents a resolver provided by a Module.
+ *
+ * A function always evaluates against a parent object and is given a set of
+ * named arguments.
  */
-export class GitRef extends BaseClient {
+export class Function_ extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent) {
+    constructor(parent, _id, _call, _description, _name) {
         super(parent);
+        this._id = undefined;
+        this._call = undefined;
+        this._description = undefined;
+        this._name = undefined;
+        this._id = _id;
+        this._call = _call;
+        this._description = _description;
+        this._name = _name;
     }
     /**
-     * The filesystem tree at this ref.
+     * The ID of the function
      */
-    tree(opts) {
-        return new Directory({
-            queryTree: [
+    id() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._id) {
+                return this._id;
+            }
+            const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "tree",
-                    args: Object.assign({}, opts),
+                    operation: "id",
                 },
-            ],
-            host: this.clientHost,
-            sessionToken: this.sessionToken,
+            ], this.client);
+            return response;
         });
     }
-}
-/**
- * A git repository.
- */
-export class GitRepository extends BaseClient {
-    /**
-     * Constructor is used for internal usage only, do not create object from it.
-     */
-    constructor(parent) {
-        super(parent);
-    }
     /**
-     * Returns details on one branch.
-     * @param name Branch's name (e.g., "main").
+     * Arguments accepted by this function, if any
      */
-    branch(name) {
-        return new GitRef({
-            queryTree: [
+    args() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "branch",
-                    args: { name },
+                    operation: "args",
                 },
-            ],
-            host: this.clientHost,
-            sessionToken: this.sessionToken,
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response.map((r) => new FunctionArg({
+                queryTree: this.queryTree,
+                host: this.clientHost,
+                sessionToken: this.sessionToken,
+            }, r.id));
         });
     }
     /**
-     * Returns details on one commit.
-     * @param id Identifier of the commit (e.g., "b6315d8f2810962c601af73f86831f6866ea798b").
+     * Execute this function using dynamic input+output types.
+     *
+     * Typically, it's preferable to invoke a function using a type
+     * safe graphql query rather than using this call field. However,
+     * call is useful for some advanced use cases where dynamically
+     * loading arbitrary modules and invoking functions in them is
+     * required.
      */
-    commit(id) {
-        return new GitRef({
-            queryTree: [
+    call(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._call) {
+                return this._call;
+            }
+            const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "commit",
-                    args: { id },
+                    operation: "call",
+                    args: Object.assign({}, opts),
                 },
-            ],
-            host: this.clientHost,
-            sessionToken: this.sessionToken,
+            ], this.client);
+            return response;
         });
     }
     /**
-     * Returns details on one tag.
-     * @param name Tag's name (e.g., "v0.3.9").
+     * A doc string for the function, if any
      */
-    tag(name) {
-        return new GitRef({
-            queryTree: [
+    description() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._description) {
+                return this._description;
+            }
+            const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "tag",
-                    args: { name },
+                    operation: "description",
                 },
-            ],
-            host: this.clientHost,
-            sessionToken: this.sessionToken,
+            ], this.client);
+            return response;
         });
     }
-}
-/**
- * Information about the host execution environment.
- */
-export class Host extends BaseClient {
-    /**
-     * Constructor is used for internal usage only, do not create object from it.
-     */
-    constructor(parent) {
-        super(parent);
-    }
     /**
-     * Accesses a directory on the host.
-     * @param path Location of the directory to access (e.g., ".").
-     * @param opts.exclude Exclude artifacts that match the given pattern (e.g., ["node_modules/", ".git*"]).
-     * @param opts.include Include only artifacts that match the given pattern (e.g., ["app/", "package.*"]).
+     * The name of the function
      */
-    directory(path, opts) {
-        return new Directory({
-            queryTree: [
+    name() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._name) {
+                return this._name;
+            }
+            const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "directory",
-                    args: Object.assign({ path }, opts),
+                    operation: "name",
                 },
-            ],
-            host: this.clientHost,
-            sessionToken: this.sessionToken,
+            ], this.client);
+            return response;
         });
     }
     /**
-     * Accesses a file on the host.
-     * @param path Location of the file to retrieve (e.g., "README.md").
+     * The type returned by this function
      */
-    file(path) {
-        return new File({
+    returnType() {
+        return new TypeDef({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "file",
-                    args: { path },
+                    operation: "returnType",
                 },
             ],
             host: this.clientHost,
@@ -1958,18 +2097,19 @@ export class Host extends BaseClient {
         });
     }
     /**
-     * Sets a secret given a user-defined name and the file path on the host, and returns the secret.
-     * The file is limited to a size of 512000 bytes.
-     * @param name The user defined name for this secret.
-     * @param path Location of the file to set as a secret.
+     * Returns the function with the provided argument
+     * @param name The name of the argument
+     * @param typeDef The type of the argument
+     * @param opts.description A doc string for the argument, if any
+     * @param opts.defaultValue A default value to use for this argument if not explicitly set by the caller, if any
      */
-    setSecretFile(name, path) {
-        return new Secret({
+    withArg(name, typeDef, opts) {
+        return new Function_({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "setSecretFile",
-                    args: { name, path },
+                    operation: "withArg",
+                    args: Object.assign({ name, typeDef }, opts),
                 },
             ],
             host: this.clientHost,
@@ -1977,90 +2117,87 @@ export class Host extends BaseClient {
         });
     }
     /**
-     * Accesses a Unix socket on the host.
-     * @param path Location of the Unix socket (e.g., "/var/run/docker.sock").
+     * Returns the function with the doc string
      */
-    unixSocket(path) {
-        return new Socket({
+    withDescription(description) {
+        return new Function_({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "unixSocket",
-                    args: { path },
+                    operation: "withDescription",
+                    args: { description },
                 },
             ],
             host: this.clientHost,
             sessionToken: this.sessionToken,
         });
     }
+    /**
+     * Call the provided function with current Function.
+     *
+     * This is useful for reusability and readability by not breaking the calling chain.
+     */
+    with(arg) {
+        return arg(this);
+    }
 }
 /**
- * A simple key value object that represents a label.
+ * An argument accepted by a function.
+ *
+ * This is a specification for an argument at function definition time, not an
+ * argument passed at function call time.
  */
-export class Label extends BaseClient {
+export class FunctionArg extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _name, _value) {
+    constructor(parent, _id, _defaultValue, _description, _name) {
         super(parent);
+        this._id = undefined;
+        this._defaultValue = undefined;
+        this._description = undefined;
         this._name = undefined;
-        this._value = undefined;
+        this._id = _id;
+        this._defaultValue = _defaultValue;
+        this._description = _description;
         this._name = _name;
-        this._value = _value;
     }
     /**
-     * The label name.
+     * The ID of the argument
      */
-    name() {
+    id() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._name) {
-                return this._name;
+            if (this._id) {
+                return this._id;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "name",
+                    operation: "id",
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * The label value.
+     * A default value to use for this argument when not explicitly set by the caller, if any
      */
-    value() {
+    defaultValue() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._value) {
-                return this._value;
+            if (this._defaultValue) {
+                return this._defaultValue;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "value",
+                    operation: "defaultValue",
                 },
             ], this.client);
             return response;
         });
     }
-}
-/**
- * A port exposed by a container.
- */
-export class Port extends BaseClient {
-    /**
-     * Constructor is used for internal usage only, do not create object from it.
-     */
-    constructor(parent, _description, _port, _protocol) {
-        super(parent);
-        this._description = undefined;
-        this._port = undefined;
-        this._protocol = undefined;
-        this._description = _description;
-        this._port = _port;
-        this._protocol = _protocol;
-    }
     /**
-     * The port description.
+     * A doc string for the argument, if any
      */
     description() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -2077,193 +2214,202 @@ export class Port extends BaseClient {
         });
     }
     /**
-     * The port number.
+     * The name of the argument
      */
-    port() {
+    name() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._port) {
-                return this._port;
+            if (this._name) {
+                return this._name;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "port",
+                    operation: "name",
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * The transport layer network protocol.
+     * The type of the argument
      */
-    protocol() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._protocol) {
-                return this._protocol;
-            }
-            const response = yield computeQuery([
+    typeDef() {
+        return new TypeDef({
+            queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "protocol",
+                    operation: "typeDef",
                 },
-            ], this.client);
-            return response;
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
         });
     }
 }
-/**
- * A collection of Dagger resources that can be queried and invoked.
- */
-export class Project extends BaseClient {
+export class FunctionCall extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _id, _name) {
+    constructor(parent, _name, _parent, _parentName, _returnValue) {
         super(parent);
-        this._id = undefined;
         this._name = undefined;
-        this._id = _id;
+        this._parent = undefined;
+        this._parentName = undefined;
+        this._returnValue = undefined;
         this._name = _name;
+        this._parent = _parent;
+        this._parentName = _parentName;
+        this._returnValue = _returnValue;
     }
     /**
-     * Commands provided by this project
+     * The argument values the function is being invoked with.
      */
-    commands() {
+    inputArgs() {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "commands",
+                    operation: "inputArgs",
                 },
                 {
-                    operation: "description id name resultType",
+                    operation: "name value",
                 },
             ], this.client);
-            return response.map((r) => new ProjectCommand({
+            return response.map((r) => new FunctionCallArgValue({
                 queryTree: this.queryTree,
                 host: this.clientHost,
                 sessionToken: this.sessionToken,
-            }, r.description, r.id, r.name, r.resultType));
+            }, r.name, r.value));
         });
     }
     /**
-     * A unique identifier for this project.
+     * The name of the function being called.
      */
-    id() {
+    name() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._id) {
-                return this._id;
+            if (this._name) {
+                return this._name;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "id",
+                    operation: "name",
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * Initialize this project from the given directory and config path
+     * The value of the parent object of the function being called.
+     * If the function is "top-level" to the module, this is always an empty object.
      */
-    load(source, configPath) {
-        return new Project({
-            queryTree: [
+    parent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._parent) {
+                return this._parent;
+            }
+            const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "load",
-                    args: { source, configPath },
+                    operation: "parent",
                 },
-            ],
-            host: this.clientHost,
-            sessionToken: this.sessionToken,
+            ], this.client);
+            return response;
         });
     }
     /**
-     * Name of the project
+     * The name of the parent object of the function being called.
+     * If the function is "top-level" to the module, this is the name of the module.
      */
-    name() {
+    parentName() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._name) {
-                return this._name;
+            if (this._parentName) {
+                return this._parentName;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "name",
+                    operation: "parentName",
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * Call the provided function with current Project.
-     *
-     * This is useful for reusability and readability by not breaking the calling chain.
+     * Set the return value of the function call to the provided value.
+     * The value should be a string of the JSON serialization of the return value.
      */
-    with(arg) {
-        return arg(this);
+    returnValue(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._returnValue) {
+                return this._returnValue;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "returnValue",
+                    args: { value },
+                },
+            ], this.client);
+            return response;
+        });
     }
 }
-/**
- * A command defined in a project that can be invoked from the CLI.
- */
-export class ProjectCommand extends BaseClient {
+export class FunctionCallArgValue extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _description, _id, _name, _resultType) {
+    constructor(parent, _name, _value) {
         super(parent);
-        this._description = undefined;
-        this._id = undefined;
         this._name = undefined;
-        this._resultType = undefined;
-        this._description = _description;
-        this._id = _id;
+        this._value = undefined;
         this._name = _name;
-        this._resultType = _resultType;
+        this._value = _value;
     }
     /**
-     * Documentation for what this command does.
+     * The name of the argument.
      */
-    description() {
+    name() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._description) {
-                return this._description;
+            if (this._name) {
+                return this._name;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "description",
+                    operation: "name",
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * Flags accepted by this command.
+     * The value of the argument represented as a string of the JSON serialization.
      */
-    flags() {
+    value() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this._value) {
+                return this._value;
+            }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "flags",
-                },
-                {
-                    operation: "description name",
+                    operation: "value",
                 },
             ], this.client);
-            return response.map((r) => new ProjectCommandFlag({
-                queryTree: this.queryTree,
-                host: this.clientHost,
-                sessionToken: this.sessionToken,
-            }, r.description, r.name));
+            return response;
         });
     }
+}
+export class GeneratedCode extends BaseClient {
     /**
-     * A unique identifier for this command.
+     * Constructor is used for internal usage only, do not create object from it.
      */
+    constructor(parent, _id) {
+        super(parent);
+        this._id = undefined;
+        this._id = _id;
+    }
     id() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._id) {
@@ -2279,168 +2425,137 @@ export class ProjectCommand extends BaseClient {
         });
     }
     /**
-     * The name of the command.
+     * The directory containing the generated code
      */
-    name() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._name) {
-                return this._name;
-            }
-            const response = yield computeQuery([
+    code() {
+        return new Directory({
+            queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "name",
+                    operation: "code",
                 },
-            ], this.client);
-            return response;
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
         });
     }
     /**
-     * The name of the type returned by this command.
+     * List of paths to mark generated in version control (i.e. .gitattributes)
      */
-    resultType() {
+    vcsGeneratedPaths() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._resultType) {
-                return this._resultType;
-            }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "resultType",
+                    operation: "vcsGeneratedPaths",
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * Subcommands, if any, that this command provides.
+     * List of paths to ignore in version control (i.e. .gitignore)
      */
-    subcommands() {
+    vcsIgnoredPaths() {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "subcommands",
-                },
-                {
-                    operation: "description id name resultType",
+                    operation: "vcsIgnoredPaths",
                 },
             ], this.client);
-            return response.map((r) => new ProjectCommand({
-                queryTree: this.queryTree,
-                host: this.clientHost,
-                sessionToken: this.sessionToken,
-            }, r.description, r.id, r.name, r.resultType));
+            return response;
         });
     }
-}
-/**
- * A flag accepted by a project command.
- */
-export class ProjectCommandFlag extends BaseClient {
-    /**
-     * Constructor is used for internal usage only, do not create object from it.
-     */
-    constructor(parent, _description, _name) {
-        super(parent);
-        this._description = undefined;
-        this._name = undefined;
-        this._description = _description;
-        this._name = _name;
-    }
     /**
-     * Documentation for what this flag sets.
+     * Set the list of paths to mark generated in version control
      */
-    description() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._description) {
-                return this._description;
-            }
-            const response = yield computeQuery([
+    withVCSGeneratedPaths(paths) {
+        return new GeneratedCode({
+            queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "description",
+                    operation: "withVCSGeneratedPaths",
+                    args: { paths },
                 },
-            ], this.client);
-            return response;
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
         });
     }
     /**
-     * The name of the flag.
+     * Set the list of paths to ignore in version control
      */
-    name() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._name) {
-                return this._name;
-            }
-            const response = yield computeQuery([
+    withVCSIgnoredPaths(paths) {
+        return new GeneratedCode({
+            queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "name",
+                    operation: "withVCSIgnoredPaths",
+                    args: { paths },
                 },
-            ], this.client);
-            return response;
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
         });
     }
+    /**
+     * Call the provided function with current GeneratedCode.
+     *
+     * This is useful for reusability and readability by not breaking the calling chain.
+     */
+    with(arg) {
+        return arg(this);
+    }
 }
-export class Client extends BaseClient {
+/**
+ * A git ref (tag, branch or commit).
+ */
+export class GitRef extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _checkVersionCompatibility, _defaultPlatform) {
+    constructor(parent) {
         super(parent);
-        this._checkVersionCompatibility = undefined;
-        this._defaultPlatform = undefined;
-        this._checkVersionCompatibility = _checkVersionCompatibility;
-        this._defaultPlatform = _defaultPlatform;
     }
     /**
-     * Constructs a cache volume for a given cache key.
-     * @param key A string identifier to target this cache volume (e.g., "modules-cache").
+     * The filesystem tree at this ref.
      */
-    cacheVolume(key) {
-        return new CacheVolume({
+    tree(opts) {
+        return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "cacheVolume",
-                    args: { key },
+                    operation: "tree",
+                    args: Object.assign({}, opts),
                 },
             ],
             host: this.clientHost,
             sessionToken: this.sessionToken,
         });
     }
+}
+/**
+ * A git repository.
+ */
+export class GitRepository extends BaseClient {
     /**
-     * Checks if the current Dagger Engine is compatible with an SDK's required version.
-     * @param version The SDK's required version.
+     * Constructor is used for internal usage only, do not create object from it.
      */
-    checkVersionCompatibility(version) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield computeQuery([
-                ...this._queryTree,
-                {
-                    operation: "checkVersionCompatibility",
-                    args: { version },
-                },
-            ], this.client);
-            return response;
-        });
+    constructor(parent) {
+        super(parent);
     }
     /**
-     * Loads a container from ID.
-     *
-     * Null ID returns an empty container (scratch).
-     * Optional platform argument initializes new containers to execute and publish as that platform.
-     * Platform defaults to that of the builder's host.
+     * Returns details on one branch.
+     * @param name Branch's name (e.g., "main").
      */
-    container(opts) {
-        return new Container({
+    branch(name) {
+        return new GitRef({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "container",
-                    args: Object.assign({}, opts),
+                    operation: "branch",
+                    args: { name },
                 },
             ],
             host: this.clientHost,
@@ -2448,66 +2563,63 @@ export class Client extends BaseClient {
         });
     }
     /**
-     * The default platform of the builder.
+     * Returns details on one commit.
+     * @param id Identifier of the commit (e.g., "b6315d8f2810962c601af73f86831f6866ea798b").
      */
-    defaultPlatform() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield computeQuery([
+    commit(id) {
+        return new GitRef({
+            queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "defaultPlatform",
+                    operation: "commit",
+                    args: { id },
                 },
-            ], this.client);
-            return response;
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
         });
     }
     /**
-     * Load a directory by ID. No argument produces an empty directory.
+     * Returns details on one tag.
+     * @param name Tag's name (e.g., "v0.3.9").
      */
-    directory(opts) {
-        return new Directory({
+    tag(name) {
+        return new GitRef({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "directory",
-                    args: Object.assign({}, opts),
+                    operation: "tag",
+                    args: { name },
                 },
             ],
             host: this.clientHost,
             sessionToken: this.sessionToken,
         });
     }
+}
+/**
+ * Information about the host execution environment.
+ */
+export class Host extends BaseClient {
     /**
-     * Loads a file by ID.
+     * Constructor is used for internal usage only, do not create object from it.
      */
-    file(id) {
-        return new File({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "file",
-                    args: { id },
-                },
-            ],
-            host: this.clientHost,
-            sessionToken: this.sessionToken,
-        });
+    constructor(parent) {
+        super(parent);
     }
     /**
-     * Queries a git repository.
-     * @param url Url of the git repository.
-     * Can be formatted as https://{host}/{owner}/{repo}, git@{host}/{owner}/{repo}
-     * Suffix ".git" is optional.
-     * @param opts.keepGitDir Set to true to keep .git directory.
-     * @param opts.experimentalServiceHost A service which must be started before the repo is fetched.
+     * Accesses a directory on the host.
+     * @param path Location of the directory to access (e.g., ".").
+     * @param opts.exclude Exclude artifacts that match the given pattern (e.g., ["node_modules/", ".git*"]).
+     * @param opts.include Include only artifacts that match the given pattern (e.g., ["app/", "package.*"]).
      */
-    git(url, opts) {
-        return new GitRepository({
+    directory(path, opts) {
+        return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "git",
-                    args: Object.assign({ url }, opts),
+                    operation: "directory",
+                    args: Object.assign({ path }, opts),
                 },
             ],
             host: this.clientHost,
@@ -2515,14 +2627,16 @@ export class Client extends BaseClient {
         });
     }
     /**
-     * Queries the host environment.
+     * Accesses a file on the host.
+     * @param path Location of the file to retrieve (e.g., "README.md").
      */
-    host() {
-        return new Host({
+    file(path) {
+        return new File({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "host",
+                    operation: "file",
+                    args: { path },
                 },
             ],
             host: this.clientHost,
@@ -2530,17 +2644,22 @@ export class Client extends BaseClient {
         });
     }
     /**
-     * Returns a file containing an http remote url content.
-     * @param url HTTP url to get the content from (e.g., "https://docs.dagger.io").
-     * @param opts.experimentalServiceHost A service which must be started before the URL is fetched.
+     * Creates a service that forwards traffic to a specified address via the host.
+     * @param ports Ports to expose via the service, forwarding through the host network.
+     *
+     * If a port's frontend is unspecified or 0, it defaults to the same as the
+     * backend port.
+     *
+     * An empty set of ports is not valid; an error will be returned.
+     * @param opts.host Upstream host to forward traffic to.
      */
-    http(url, opts) {
-        return new File({
+    service(ports, opts) {
+        return new Service({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "http",
-                    args: Object.assign({ url }, opts),
+                    operation: "service",
+                    args: Object.assign({ ports }, opts),
                 },
             ],
             host: this.clientHost,
@@ -2548,18 +2667,18 @@ export class Client extends BaseClient {
         });
     }
     /**
-     * Creates a named sub-pipeline.
-     * @param name Pipeline name.
-     * @param opts.description Pipeline description.
-     * @param opts.labels Pipeline labels.
+     * Sets a secret given a user-defined name and the file path on the host, and returns the secret.
+     * The file is limited to a size of 512000 bytes.
+     * @param name The user defined name for this secret.
+     * @param path Location of the file to set as a secret.
      */
-    pipeline(name, opts) {
-        return new Client({
+    setSecretFile(name, path) {
+        return new Secret({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "pipeline",
-                    args: Object.assign({ name }, opts),
+                    operation: "setSecretFile",
+                    args: { name, path },
                 },
             ],
             host: this.clientHost,
@@ -2567,15 +2686,30 @@ export class Client extends BaseClient {
         });
     }
     /**
-     * Load a project from ID.
+     * Creates a tunnel that forwards traffic from the host to a service.
+     * @param service Service to send traffic from the tunnel.
+     * @param opts.native Map each service port to the same port on the host, as if the service were
+     * running natively.
+     *
+     * Note: enabling may result in port conflicts.
+     * @param opts.ports Configure explicit port forwarding rules for the tunnel.
+     *
+     * If a port's frontend is unspecified or 0, a random port will be chosen by
+     * the host.
+     *
+     * If no ports are given, all of the service's ports are forwarded. If native
+     * is true, each port maps to the same port on the host. If native is false,
+     * each port maps to a random port chosen by the host.
+     *
+     * If ports are given and native is true, the ports are additive.
      */
-    project(opts) {
-        return new Project({
+    tunnel(service, opts) {
+        return new Service({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "project",
-                    args: Object.assign({}, opts),
+                    operation: "tunnel",
+                    args: Object.assign({ service }, opts),
                 },
             ],
             host: this.clientHost,
@@ -2583,97 +2717,119 @@ export class Client extends BaseClient {
         });
     }
     /**
-     * Load a project command from ID.
+     * Accesses a Unix socket on the host.
+     * @param path Location of the Unix socket (e.g., "/var/run/docker.sock").
      */
-    projectCommand(opts) {
-        return new ProjectCommand({
+    unixSocket(path) {
+        return new Socket({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "projectCommand",
-                    args: Object.assign({}, opts),
+                    operation: "unixSocket",
+                    args: { path },
                 },
             ],
             host: this.clientHost,
             sessionToken: this.sessionToken,
         });
     }
+}
+/**
+ * A simple key value object that represents a label.
+ */
+export class Label extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _name, _value) {
+        super(parent);
+        this._name = undefined;
+        this._value = undefined;
+        this._name = _name;
+        this._value = _value;
+    }
     /**
-     * Loads a secret from its ID.
+     * The label name.
      */
-    secret(id) {
-        return new Secret({
-            queryTree: [
+    name() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._name) {
+                return this._name;
+            }
+            const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "secret",
-                    args: { id },
+                    operation: "name",
                 },
-            ],
-            host: this.clientHost,
-            sessionToken: this.sessionToken,
+            ], this.client);
+            return response;
         });
     }
     /**
-     * Sets a secret given a user defined name to its plaintext and returns the secret.
-     * The plaintext value is limited to a size of 128000 bytes.
-     * @param name The user defined name for this secret
-     * @param plaintext The plaintext of the secret
+     * The label value.
      */
-    setSecret(name, plaintext) {
-        return new Secret({
-            queryTree: [
+    value() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._value) {
+                return this._value;
+            }
+            const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "setSecret",
-                    args: { name, plaintext },
+                    operation: "value",
                 },
-            ],
-            host: this.clientHost,
-            sessionToken: this.sessionToken,
+            ], this.client);
+            return response;
         });
     }
+}
+/**
+ * A definition of a list type in a Module.
+ */
+export class ListTypeDef extends BaseClient {
     /**
-     * Loads a socket by its ID.
+     * Constructor is used for internal usage only, do not create object from it.
      */
-    socket(opts) {
-        return new Socket({
+    constructor(parent) {
+        super(parent);
+    }
+    /**
+     * The type of the elements in the list
+     */
+    elementTypeDef() {
+        return new TypeDef({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "socket",
-                    args: Object.assign({}, opts),
+                    operation: "elementTypeDef",
                 },
             ],
             host: this.clientHost,
             sessionToken: this.sessionToken,
         });
     }
-    /**
-     * Call the provided function with current Client.
-     *
-     * This is useful for reusability and readability by not breaking the calling chain.
-     */
-    with(arg) {
-        return arg(this);
-    }
 }
-/**
- * A reference to a secret value, which can be handled more safely than the value itself.
- */
-export class Secret extends BaseClient {
+export class Module_ extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _id, _plaintext) {
+    constructor(parent, _id, _description, _name, _sdk, _serve, _sourceDirectorySubPath) {
         super(parent);
         this._id = undefined;
-        this._plaintext = undefined;
+        this._description = undefined;
+        this._name = undefined;
+        this._sdk = undefined;
+        this._serve = undefined;
+        this._sourceDirectorySubPath = undefined;
         this._id = _id;
-        this._plaintext = _plaintext;
+        this._description = _description;
+        this._name = _name;
+        this._sdk = _sdk;
+        this._serve = _serve;
+        this._sourceDirectorySubPath = _sourceDirectorySubPath;
     }
     /**
-     * The identifier for this secret.
+     * The ID of the module
      */
     id() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -2690,47 +2846,1428 @@ export class Secret extends BaseClient {
         });
     }
     /**
-     * The value of this secret.
+     * Modules used by this module
      */
-    plaintext() {
+    dependencies() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._plaintext) {
-                return this._plaintext;
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "dependencies",
+                },
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response.map((r) => new Module_({
+                queryTree: this.queryTree,
+                host: this.clientHost,
+                sessionToken: this.sessionToken,
+            }, r.id));
+        });
+    }
+    /**
+     * The dependencies as configured by the module
+     */
+    dependencyConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "dependencyConfig",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * The doc string of the module, if any
+     */
+    description() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._description) {
+                return this._description;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "plaintext",
+                    operation: "description",
                 },
             ], this.client);
             return response;
         });
     }
-}
-export class Socket extends BaseClient {
     /**
-     * Constructor is used for internal usage only, do not create object from it.
+     * The code generated by the SDK's runtime
      */
-    constructor(parent, _id) {
-        super(parent);
-        this._id = undefined;
-        this._id = _id;
+    generatedCode() {
+        return new GeneratedCode({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "generatedCode",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
     }
     /**
-     * The content-addressed identifier of the socket.
+     * The name of the module
      */
-    id() {
+    name() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._id) {
-                return this._id;
+            if (this._name) {
+                return this._name;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "id",
+                    operation: "name",
                 },
             ], this.client);
             return response;
         });
     }
+    /**
+     * Objects served by this module
+     */
+    objects() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "objects",
+                },
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response.map((r) => new TypeDef({
+                queryTree: this.queryTree,
+                host: this.clientHost,
+                sessionToken: this.sessionToken,
+            }, r.id));
+        });
+    }
+    /**
+     * The SDK used by this module. Either a name of a builtin SDK or a module ref pointing to the SDK's implementation.
+     */
+    sdk() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._sdk) {
+                return this._sdk;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "sdk",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Serve a module's API in the current session.
+     *     Note: this can only be called once per session.
+     *     In the future, it could return a stream or service to remove the side effect.
+     */
+    serve() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._serve) {
+                return this._serve;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "serve",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * The directory containing the module's source code
+     */
+    sourceDirectory() {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "sourceDirectory",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * The module's subpath within the source directory
+     */
+    sourceDirectorySubPath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._sourceDirectorySubPath) {
+                return this._sourceDirectorySubPath;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "sourceDirectorySubPath",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * This module plus the given Object type and associated functions
+     */
+    withObject(object) {
+        return new Module_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withObject",
+                    args: { object },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Call the provided function with current Module.
+     *
+     * This is useful for reusability and readability by not breaking the calling chain.
+     */
+    with(arg) {
+        return arg(this);
+    }
+}
+/**
+ * Static configuration for a module (e.g. parsed contents of dagger.json)
+ */
+export class ModuleConfig extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _name, _root, _sdk) {
+        super(parent);
+        this._name = undefined;
+        this._root = undefined;
+        this._sdk = undefined;
+        this._name = _name;
+        this._root = _root;
+        this._sdk = _sdk;
+    }
+    /**
+     * Modules that this module depends on.
+     */
+    dependencies() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "dependencies",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Exclude these file globs when loading the module root.
+     */
+    exclude() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "exclude",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Include only these file globs when loading the module root.
+     */
+    include() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "include",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * The name of the module.
+     */
+    name() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._name) {
+                return this._name;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "name",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * The root directory of the module's project, which may be above the module source code.
+     */
+    root() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._root) {
+                return this._root;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "root",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Either the name of a built-in SDK ('go', 'python', etc.) OR a module reference pointing to the SDK's module implementation.
+     */
+    sdk() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._sdk) {
+                return this._sdk;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "sdk",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+}
+/**
+ * A definition of a custom object defined in a Module.
+ */
+export class ObjectTypeDef extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _description, _name) {
+        super(parent);
+        this._description = undefined;
+        this._name = undefined;
+        this._description = _description;
+        this._name = _name;
+    }
+    /**
+     * The doc string for the object, if any
+     */
+    description() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._description) {
+                return this._description;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "description",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Static fields defined on this object, if any
+     */
+    fields() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "fields",
+                },
+                {
+                    operation: "description name",
+                },
+            ], this.client);
+            return response.map((r) => new FieldTypeDef({
+                queryTree: this.queryTree,
+                host: this.clientHost,
+                sessionToken: this.sessionToken,
+            }, r.description, r.name));
+        });
+    }
+    /**
+     * Functions defined on this object, if any
+     */
+    functions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "functions",
+                },
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response.map((r) => new Function_({
+                queryTree: this.queryTree,
+                host: this.clientHost,
+                sessionToken: this.sessionToken,
+            }, r.id));
+        });
+    }
+    /**
+     * The name of the object
+     */
+    name() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._name) {
+                return this._name;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "name",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+}
+/**
+ * A port exposed by a container.
+ */
+export class Port extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _description, _port, _protocol) {
+        super(parent);
+        this._description = undefined;
+        this._port = undefined;
+        this._protocol = undefined;
+        this._description = _description;
+        this._port = _port;
+        this._protocol = _protocol;
+    }
+    /**
+     * The port description.
+     */
+    description() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._description) {
+                return this._description;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "description",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * The port number.
+     */
+    port() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._port) {
+                return this._port;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "port",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * The transport layer network protocol.
+     */
+    protocol() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._protocol) {
+                return this._protocol;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "protocol",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+}
+export class Client extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _checkVersionCompatibility, _defaultPlatform) {
+        super(parent);
+        this._checkVersionCompatibility = undefined;
+        this._defaultPlatform = undefined;
+        this._checkVersionCompatibility = _checkVersionCompatibility;
+        this._defaultPlatform = _defaultPlatform;
+    }
+    /**
+     * Constructs a cache volume for a given cache key.
+     * @param key A string identifier to target this cache volume (e.g., "modules-cache").
+     */
+    cacheVolume(key) {
+        return new CacheVolume({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "cacheVolume",
+                    args: { key },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Checks if the current Dagger Engine is compatible with an SDK's required version.
+     * @param version The SDK's required version.
+     */
+    checkVersionCompatibility(version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "checkVersionCompatibility",
+                    args: { version },
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Creates a scratch container or loads one by ID.
+     *
+     * Optional platform argument initializes new containers to execute and publish
+     * as that platform. Platform defaults to that of the builder's host.
+     */
+    container(opts) {
+        return new Container({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "container",
+                    args: Object.assign({}, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * The FunctionCall context that the SDK caller is currently executing in.
+     * If the caller is not currently executing in a function, this will return
+     * an error.
+     */
+    currentFunctionCall() {
+        return new FunctionCall({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "currentFunctionCall",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * The module currently being served in the session, if any.
+     */
+    currentModule() {
+        return new Module_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "currentModule",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * The default platform of the builder.
+     */
+    defaultPlatform() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "defaultPlatform",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Creates an empty directory or loads one by ID.
+     */
+    directory(opts) {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "directory",
+                    args: Object.assign({}, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Loads a file by ID.
+     * @deprecated Use loadFileFromID instead.
+     */
+    file(id) {
+        return new File({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "file",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Create a function.
+     */
+    function_(name, returnType) {
+        return new Function_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "function",
+                    args: { name, returnType },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Create a code generation result, given a directory containing the generated
+     * code.
+     */
+    generatedCode(code) {
+        return new GeneratedCode({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "generatedCode",
+                    args: { code },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Queries a git repository.
+     * @param url Url of the git repository.
+     * Can be formatted as https://{host}/{owner}/{repo}, git@{host}/{owner}/{repo}
+     * Suffix ".git" is optional.
+     * @param opts.keepGitDir Set to true to keep .git directory.
+     * @param opts.experimentalServiceHost A service which must be started before the repo is fetched.
+     */
+    git(url, opts) {
+        return new GitRepository({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "git",
+                    args: Object.assign({ url }, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Queries the host environment.
+     */
+    host() {
+        return new Host({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "host",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Returns a file containing an http remote url content.
+     * @param url HTTP url to get the content from (e.g., "https://docs.dagger.io").
+     * @param opts.experimentalServiceHost A service which must be started before the URL is fetched.
+     */
+    http(url, opts) {
+        return new File({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "http",
+                    args: Object.assign({ url }, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load a CacheVolume from its ID.
+     */
+    loadCacheVolumeFromID(id) {
+        return new CacheVolume({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadCacheVolumeFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Loads a container from an ID.
+     */
+    loadContainerFromID(id) {
+        return new Container({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadContainerFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load a Directory from its ID.
+     */
+    loadDirectoryFromID(id) {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadDirectoryFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load a File from its ID.
+     */
+    loadFileFromID(id) {
+        return new File({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadFileFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load a function argument by ID.
+     */
+    loadFunctionArgFromID(id) {
+        return new FunctionArg({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadFunctionArgFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load a function by ID.
+     */
+    loadFunctionFromID(id) {
+        return new Function_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadFunctionFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load a GeneratedCode by ID.
+     */
+    loadGeneratedCodeFromID(id) {
+        return new GeneratedCode({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadGeneratedCodeFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load a module by ID.
+     */
+    loadModuleFromID(id) {
+        return new Module_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadModuleFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load a Secret from its ID.
+     */
+    loadSecretFromID(id) {
+        return new Secret({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadSecretFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Loads a service from ID.
+     */
+    loadServiceFromID(id) {
+        return new Service({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadServiceFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load a Socket from its ID.
+     */
+    loadSocketFromID(id) {
+        return new Socket({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadSocketFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load a TypeDef by ID.
+     */
+    loadTypeDefFromID(id) {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadTypeDefFromID",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Create a new module.
+     */
+    module_() {
+        return new Module_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "module",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load the static configuration for a module from the given source directory and optional subpath.
+     */
+    moduleConfig(sourceDirectory, opts) {
+        return new ModuleConfig({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "moduleConfig",
+                    args: Object.assign({ sourceDirectory }, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Creates a named sub-pipeline.
+     * @param name Pipeline name.
+     * @param opts.description Pipeline description.
+     * @param opts.labels Pipeline labels.
+     */
+    pipeline(name, opts) {
+        return new Client({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "pipeline",
+                    args: Object.assign({ name }, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Loads a secret from its ID.
+     * @deprecated Use loadSecretFromID instead
+     */
+    secret(id) {
+        return new Secret({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "secret",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Sets a secret given a user defined name to its plaintext and returns the secret.
+     * The plaintext value is limited to a size of 128000 bytes.
+     * @param name The user defined name for this secret
+     * @param plaintext The plaintext of the secret
+     */
+    setSecret(name, plaintext) {
+        return new Secret({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "setSecret",
+                    args: { name, plaintext },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Loads a socket by its ID.
+     * @deprecated Use loadSocketFromID instead.
+     */
+    socket(opts) {
+        return new Socket({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "socket",
+                    args: Object.assign({}, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Create a new TypeDef.
+     */
+    typeDef() {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "typeDef",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Call the provided function with current Client.
+     *
+     * This is useful for reusability and readability by not breaking the calling chain.
+     */
+    with(arg) {
+        return arg(this);
+    }
+}
+/**
+ * A reference to a secret value, which can be handled more safely than the value itself.
+ */
+export class Secret extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _id, _plaintext) {
+        super(parent);
+        this._id = undefined;
+        this._plaintext = undefined;
+        this._id = _id;
+        this._plaintext = _plaintext;
+    }
+    /**
+     * The identifier for this secret.
+     */
+    id() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._id) {
+                return this._id;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * The value of this secret.
+     */
+    plaintext() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._plaintext) {
+                return this._plaintext;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "plaintext",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+}
+export class Service extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _id, _endpoint, _hostname, _start, _stop) {
+        super(parent);
+        this._id = undefined;
+        this._endpoint = undefined;
+        this._hostname = undefined;
+        this._start = undefined;
+        this._stop = undefined;
+        this._id = _id;
+        this._endpoint = _endpoint;
+        this._hostname = _hostname;
+        this._start = _start;
+        this._stop = _stop;
+    }
+    /**
+     * A unique identifier for this service.
+     */
+    id() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._id) {
+                return this._id;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Retrieves an endpoint that clients can use to reach this container.
+     *
+     * If no port is specified, the first exposed port is used. If none exist an error is returned.
+     *
+     * If a scheme is specified, a URL is returned. Otherwise, a host:port pair is returned.
+     * @param opts.port The exposed port number for the endpoint
+     * @param opts.scheme Return a URL with the given scheme, eg. http for http://
+     */
+    endpoint(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._endpoint) {
+                return this._endpoint;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "endpoint",
+                    args: Object.assign({}, opts),
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Retrieves a hostname which can be used by clients to reach this container.
+     */
+    hostname() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._hostname) {
+                return this._hostname;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "hostname",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Retrieves the list of ports provided by the service.
+     */
+    ports() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "ports",
+                },
+                {
+                    operation: "description port protocol",
+                },
+            ], this.client);
+            return response.map((r) => new Port({
+                queryTree: this.queryTree,
+                host: this.clientHost,
+                sessionToken: this.sessionToken,
+            }, r.description, r.port, r.protocol));
+        });
+    }
+    /**
+     * Start the service and wait for its health checks to succeed.
+     *
+     * Services bound to a Container do not need to be manually started.
+     */
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "start",
+                },
+            ], this.client);
+            return this;
+        });
+    }
+    /**
+     * Stop the service.
+     */
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "stop",
+                },
+            ], this.client);
+            return this;
+        });
+    }
+}
+export class Socket extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _id) {
+        super(parent);
+        this._id = undefined;
+        this._id = _id;
+    }
+    /**
+     * The content-addressed identifier of the socket.
+     */
+    id() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._id) {
+                return this._id;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+}
+/**
+ * A definition of a parameter or return type in a Module.
+ */
+export class TypeDef extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _id, _kind, _optional) {
+        super(parent);
+        this._id = undefined;
+        this._kind = undefined;
+        this._optional = undefined;
+        this._id = _id;
+        this._kind = _kind;
+        this._optional = _optional;
+    }
+    id() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._id) {
+                return this._id;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "id",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * If kind is LIST, the list-specific type definition.
+     * If kind is not LIST, this will be null.
+     */
+    asList() {
+        return new ListTypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "asList",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * If kind is OBJECT, the object-specific type definition.
+     * If kind is not OBJECT, this will be null.
+     */
+    asObject() {
+        return new ObjectTypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "asObject",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * The kind of type this is (e.g. primitive, list, object)
+     */
+    kind() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._kind) {
+                return this._kind;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "kind",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Whether this type can be set to null. Defaults to false.
+     */
+    optional() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._optional) {
+                return this._optional;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "optional",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Adds a static field for an Object TypeDef, failing if the type is not an object.
+     * @param name The name of the field in the object
+     * @param typeDef The type of the field
+     * @param opts.description A doc string for the field, if any
+     */
+    withField(name, typeDef, opts) {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withField",
+                    args: Object.assign({ name, typeDef }, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Adds a function for an Object TypeDef, failing if the type is not an object.
+     */
+    withFunction(function_) {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withFunction",
+                    args: { function_ },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Sets the kind of the type.
+     */
+    withKind(kind) {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withKind",
+                    args: { kind },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Returns a TypeDef of kind List with the provided type for its elements.
+     */
+    withListOf(elementType) {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withListOf",
+                    args: { elementType },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Returns a TypeDef of kind Object with the provided name.
+     *
+     * Note that an object's fields and functions may be omitted if the intent is
+     * only to refer to an object. This is how functions are able to return their
+     * own object, or any other circular reference.
+     */
+    withObject(name, opts) {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withObject",
+                    args: Object.assign({ name }, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Sets whether this type can be set to null.
+     */
+    withOptional(optional) {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withOptional",
+                    args: { optional },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Call the provided function with current TypeDef.
+     *
+     * This is useful for reusability and readability by not breaking the calling chain.
+     */
+    with(arg) {
+        return arg(this);
+    }
 }