@dagger.io/dagger 0.8.6 → 0.8.8

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,56 @@ 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, _endpoint, _envVariable, _export, _hostname, _imageRef, _label, _platform, _publish, _shellEndpoint, _stderr, _stdout, _sync, _user, _workdir) {
         super(parent);
+        this._id = undefined;
         this._endpoint = 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._id = _id;
         this._endpoint = _endpoint;
         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;
+        });
+    }
     /**
      * Initializes this container from a Dockerfile build.
      * @param context Directory context used by the Dockerfile.
@@ -412,23 +469,6 @@ export class Container extends BaseClient {
             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 +495,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 +650,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.
      *
@@ -1325,15 +1385,62 @@ 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.
+     * @param opts.runtime A pre-built runtime container to use instead of building one from the
+     * source code. This is useful for bootstrapping.
+     *
+     * You should ignore this unless you're building a Dagger SDK.
+     */
+    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 +1552,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.
@@ -1688,6 +1778,72 @@ export class EnvVariable extends BaseClient {
         });
     }
 }
+/**
+ * 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 FieldTypeDef 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;
+    }
+    /**
+     * A doc string for the field, 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;
+        });
+    }
+    /**
+     * The name of the field in 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;
+        });
+    }
+    /**
+     * The type of the field
+     */
+    typeDef() {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "typeDef",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+}
 /**
  * A file.
  */
@@ -1695,19 +1851,36 @@ export class File extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _contents, _export, _id, _size, _sync) {
+    constructor(parent, _id, _contents, _export, _size, _sync) {
         super(parent);
+        this._id = undefined;
         this._contents = undefined;
         this._export = undefined;
-        this._id = undefined;
         this._size = undefined;
         this._sync = undefined;
+        this._id = _id;
         this._contents = _contents;
         this._export = _export;
-        this._id = _id;
         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.
      */
@@ -1746,23 +1919,6 @@ export class File extends BaseClient {
             return response;
         });
     }
-    /**
-     * 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;
-        });
-    }
     /**
      * Gets the size of the file, in bytes.
      */
@@ -1823,47 +1979,588 @@ 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) {
+    args() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "args",
+                },
+                {
+                    operation: "defaultValue description name",
+                },
+            ], this.client);
+            return response.map((r) => new FunctionArg({
+                queryTree: this.queryTree,
+                host: this.clientHost,
+                sessionToken: this.sessionToken,
+            }, r.defaultValue, r.description, r.name));
+        });
+    }
+    /**
+     * 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.
+     */
+    call(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._call) {
+                return this._call;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "call",
+                    args: Object.assign({}, opts),
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * A doc string for the function, 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;
+        });
+    }
+    /**
+     * The name of the function
+     */
+    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 type returned by this function
+     */
+    returnType() {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "returnType",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * 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
+     */
+    withArg(name, typeDef, opts) {
+        return new Function_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withArg",
+                    args: Object.assign({ name, typeDef }, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Returns the function with the doc string
+     */
+    withDescription(description) {
+        return new Function_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    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);
+    }
+}
+/**
+ * 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 FunctionArg extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _defaultValue, _description, _name) {
+        super(parent);
+        this._defaultValue = undefined;
+        this._description = undefined;
+        this._name = undefined;
+        this._defaultValue = _defaultValue;
+        this._description = _description;
+        this._name = _name;
+    }
+    /**
+     * A default value to use for this argument when not explicitly set by the caller, if any
+     */
+    defaultValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._defaultValue) {
+                return this._defaultValue;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "defaultValue",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * A doc string for the argument, 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;
+        });
+    }
+    /**
+     * The name of the argument
+     */
+    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 type of the argument
+     */
+    typeDef() {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "typeDef",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+}
+export class FunctionCall extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _name, _parent, _parentName, _returnValue) {
+        super(parent);
+        this._name = undefined;
+        this._parent = undefined;
+        this._parentName = undefined;
+        this._returnValue = undefined;
+        this._name = _name;
+        this._parent = _parent;
+        this._parentName = _parentName;
+        this._returnValue = _returnValue;
+    }
+    /**
+     * The argument values the function is being invoked with.
+     */
+    inputArgs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "inputArgs",
+                },
+                {
+                    operation: "name value",
+                },
+            ], this.client);
+            return response.map((r) => new FunctionCallArgValue({
+                queryTree: this.queryTree,
+                host: this.clientHost,
+                sessionToken: this.sessionToken,
+            }, r.name, r.value));
+        });
+    }
+    /**
+     * The name of the function being called.
+     */
+    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 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.
+     */
+    parent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._parent) {
+                return this._parent;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "parent",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * 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.
+     */
+    parentName() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._parentName) {
+                return this._parentName;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "parentName",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * 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.
+     */
+    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;
+        });
+    }
+}
+export class FunctionCallArgValue 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;
+    }
+    /**
+     * The name of the argument.
+     */
+    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 value of the argument represented as a string of the JSON serialization.
+     */
+    value() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._value) {
+                return this._value;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "value",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+}
+export class GeneratedCode 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;
+    }
+    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 directory containing the generated code
+     */
+    code() {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "code",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * List of paths to mark generated in version control (i.e. .gitattributes)
+     */
+    vcsGeneratedPaths() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "vcsGeneratedPaths",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * List of paths to ignore in version control (i.e. .gitignore)
+     */
+    vcsIgnoredPaths() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "vcsIgnoredPaths",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * Set the directory containing the generated code
+     */
+    withCode(code) {
+        return new GeneratedCode({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withCode",
+                    args: { code },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Set the list of paths to mark generated in version control
+     */
+    withVCSGeneratedPaths(paths) {
+        return new GeneratedCode({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withVCSGeneratedPaths",
+                    args: { paths },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Set the list of paths to ignore in version control
+     */
+    withVCSIgnoredPaths(paths) {
+        return new GeneratedCode({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withVCSIgnoredPaths",
+                    args: { paths },
+                },
+            ],
+            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);
+    }
+}
+/**
+ * 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) {
+        super(parent);
+    }
+    /**
+     * The filesystem tree at this ref.
+     */
+    tree(opts) {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "tree",
+                    args: Object.assign({}, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+}
+/**
+ * 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").
+     */
+    branch(name) {
         return new GitRef({
             queryTree: [
                 ...this._queryTree,
@@ -2044,135 +2741,237 @@ export class Label extends BaseClient {
     }
 }
 /**
- * A port exposed by a container.
+ * A definition of a list type in a Module.
  */
-export class Port extends BaseClient {
+export class ListTypeDef extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _description, _port, _protocol) {
+    constructor(parent) {
+        super(parent);
+    }
+    /**
+     * The type of the elements in the list
+     */
+    elementTypeDef() {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "elementTypeDef",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+}
+export class Module_ extends BaseClient {
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _id, _description, _name, _sdk, _sdkRuntime, _serve, _sourceDirectorySubPath) {
         super(parent);
+        this._id = undefined;
         this._description = undefined;
-        this._port = undefined;
-        this._protocol = undefined;
+        this._name = undefined;
+        this._sdk = undefined;
+        this._sdkRuntime = undefined;
+        this._serve = undefined;
+        this._sourceDirectorySubPath = undefined;
+        this._id = _id;
         this._description = _description;
-        this._port = _port;
-        this._protocol = _protocol;
+        this._name = _name;
+        this._sdk = _sdk;
+        this._sdkRuntime = _sdkRuntime;
+        this._serve = _serve;
+        this._sourceDirectorySubPath = _sourceDirectorySubPath;
     }
     /**
-     * The port description.
+     * The ID of the module
      */
-    description() {
+    id() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._description) {
-                return this._description;
+            if (this._id) {
+                return this._id;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "description",
+                    operation: "id",
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * The port number.
+     * Modules used by this module
      */
-    port() {
+    dependencies() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._port) {
-                return this._port;
-            }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "port",
+                    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 transport layer network protocol.
+     * The doc string of the module, if any
      */
-    protocol() {
+    description() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._protocol) {
-                return this._protocol;
+            if (this._description) {
+                return this._description;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "protocol",
+                    operation: "description",
                 },
             ], this.client);
             return response;
         });
     }
-}
-/**
- * A collection of Dagger resources that can be queried and invoked.
- */
-export class Project 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, _name) {
-        super(parent);
-        this._id = undefined;
-        this._name = undefined;
-        this._id = _id;
-        this._name = _name;
+    generatedCode() {
+        return new GeneratedCode({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "generatedCode",
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * 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;
+        });
     }
     /**
-     * Commands provided by this project
+     * Objects served by this module
      */
-    commands() {
+    objects() {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "commands",
+                    operation: "objects",
                 },
                 {
-                    operation: "description id name resultType",
+                    operation: "id",
                 },
             ], this.client);
-            return response.map((r) => new ProjectCommand({
+            return response.map((r) => new TypeDef({
                 queryTree: this.queryTree,
                 host: this.clientHost,
                 sessionToken: this.sessionToken,
-            }, r.description, r.id, r.name, r.resultType));
+            }, r.id));
         });
     }
     /**
-     * A unique identifier for this project.
+     * The SDK used by this module
      */
-    id() {
+    sdk() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._id) {
-                return this._id;
+            if (this._sdk) {
+                return this._sdk;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "id",
+                    operation: "sdk",
+                },
+            ], this.client);
+            return response;
+        });
+    }
+    /**
+     * The SDK runtime module image ref.
+     */
+    sdkRuntime() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._sdkRuntime) {
+                return this._sdkRuntime;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "sdkRuntime",
+                },
+            ], 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(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._serve) {
+                return this._serve;
+            }
+            const response = yield computeQuery([
+                ...this._queryTree,
+                {
+                    operation: "serve",
+                    args: Object.assign({}, opts),
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * Initialize this project from the given directory and config path
+     * The directory containing the module's source code
      */
-    load(source, configPath) {
-        return new Project({
+    sourceDirectory() {
+        return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "load",
-                    args: { source, configPath },
+                    operation: "sourceDirectory",
                 },
             ],
             host: this.clientHost,
@@ -2180,24 +2979,40 @@ export class Project extends BaseClient {
         });
     }
     /**
-     * Name of the project
+     * The module's subpath within the source directory
      */
-    name() {
+    sourceDirectorySubPath() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._name) {
-                return this._name;
+            if (this._sourceDirectorySubPath) {
+                return this._sourceDirectorySubPath;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "name",
+                    operation: "sourceDirectorySubPath",
                 },
             ], this.client);
             return response;
         });
     }
     /**
-     * Call the provided function with current Project.
+     * 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.
      */
@@ -2206,25 +3021,21 @@ export class Project extends BaseClient {
     }
 }
 /**
- * A command defined in a project that can be invoked from the CLI.
+ * A definition of a custom object defined in a Module.
  */
-export class ProjectCommand extends BaseClient {
+export class ObjectTypeDef extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _description, _id, _name, _resultType) {
+    constructor(parent, _description, _name) {
         super(parent);
         this._description = undefined;
-        this._id = undefined;
         this._name = undefined;
-        this._resultType = undefined;
         this._description = _description;
-        this._id = _id;
         this._name = _name;
-        this._resultType = _resultType;
     }
     /**
-     * Documentation for what this command does.
+     * The doc string for the object, if any
      */
     description() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -2241,20 +3052,20 @@ export class ProjectCommand extends BaseClient {
         });
     }
     /**
-     * Flags accepted by this command.
+     * Static fields defined on this object, if any
      */
-    flags() {
+    fields() {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "flags",
+                    operation: "fields",
                 },
                 {
                     operation: "description name",
                 },
             ], this.client);
-            return response.map((r) => new ProjectCommandFlag({
+            return response.map((r) => new FieldTypeDef({
                 queryTree: this.queryTree,
                 host: this.clientHost,
                 sessionToken: this.sessionToken,
@@ -2262,24 +3073,28 @@ export class ProjectCommand extends BaseClient {
         });
     }
     /**
-     * A unique identifier for this command.
+     * Functions defined on this object, if any
      */
-    id() {
+    functions() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._id) {
-                return this._id;
-            }
             const response = yield computeQuery([
                 ...this._queryTree,
+                {
+                    operation: "functions",
+                },
                 {
                     operation: "id",
                 },
             ], this.client);
-            return response;
+            return response.map((r) => new Function_({
+                queryTree: this.queryTree,
+                host: this.clientHost,
+                sessionToken: this.sessionToken,
+            }, r.id));
         });
     }
     /**
-     * The name of the command.
+     * The name of the object
      */
     name() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -2295,61 +3110,25 @@ export class ProjectCommand extends BaseClient {
             return response;
         });
     }
-    /**
-     * The name of the type returned by this command.
-     */
-    resultType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._resultType) {
-                return this._resultType;
-            }
-            const response = yield computeQuery([
-                ...this._queryTree,
-                {
-                    operation: "resultType",
-                },
-            ], this.client);
-            return response;
-        });
-    }
-    /**
-     * Subcommands, if any, that this command provides.
-     */
-    subcommands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield computeQuery([
-                ...this._queryTree,
-                {
-                    operation: "subcommands",
-                },
-                {
-                    operation: "description id name resultType",
-                },
-            ], 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));
-        });
-    }
 }
 /**
- * A flag accepted by a project command.
+ * A port exposed by a container.
  */
-export class ProjectCommandFlag extends BaseClient {
+export class Port extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _description, _name) {
+    constructor(parent, _description, _port, _protocol) {
         super(parent);
         this._description = undefined;
-        this._name = undefined;
+        this._port = undefined;
+        this._protocol = undefined;
         this._description = _description;
-        this._name = _name;
+        this._port = _port;
+        this._protocol = _protocol;
     }
     /**
-     * Documentation for what this flag sets.
+     * The port description.
      */
     description() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -2366,17 +3145,34 @@ export class ProjectCommandFlag extends BaseClient {
         });
     }
     /**
-     * The name of the flag.
+     * The port number.
      */
-    name() {
+    port() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._name) {
-                return this._name;
+            if (this._port) {
+                return this._port;
             }
             const response = yield computeQuery([
                 ...this._queryTree,
                 {
-                    operation: "name",
+                    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;
@@ -2447,6 +3243,38 @@ export class Client extends BaseClient {
             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.
      */
@@ -2493,6 +3321,38 @@ export class Client extends BaseClient {
             sessionToken: this.sessionToken,
         });
     }
+    /**
+     * Load a function by ID
+     */
+    function_(id) {
+        return new Function_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "function",
+                    args: { id },
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
+    /**
+     * Load GeneratedCode by ID, or create a new one if id is unset.
+     */
+    generatedCode(opts) {
+        return new GeneratedCode({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "generatedCode",
+                    args: Object.assign({}, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
     /**
      * Queries a git repository.
      * @param url Url of the git repository.
@@ -2548,18 +3408,15 @@ export class Client extends BaseClient {
         });
     }
     /**
-     * Creates a named sub-pipeline.
-     * @param name Pipeline name.
-     * @param opts.description Pipeline description.
-     * @param opts.labels Pipeline labels.
+     * Load a module by ID, or create a new one if id is unset.
      */
-    pipeline(name, opts) {
-        return new Client({
+    module_(opts) {
+        return new Module_({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "pipeline",
-                    args: Object.assign({ name }, opts),
+                    operation: "module",
+                    args: Object.assign({}, opts),
                 },
             ],
             host: this.clientHost,
@@ -2567,15 +3424,15 @@ export class Client extends BaseClient {
         });
     }
     /**
-     * Load a project from ID.
+     * Create a new function from the provided definition.
      */
-    project(opts) {
-        return new Project({
+    newFunction(name, returnType) {
+        return new Function_({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "project",
-                    args: Object.assign({}, opts),
+                    operation: "newFunction",
+                    args: { name, returnType },
                 },
             ],
             host: this.clientHost,
@@ -2583,15 +3440,18 @@ export class Client extends BaseClient {
         });
     }
     /**
-     * Load a project command from ID.
+     * Creates a named sub-pipeline.
+     * @param name Pipeline name.
+     * @param opts.description Pipeline description.
+     * @param opts.labels Pipeline labels.
      */
-    projectCommand(opts) {
-        return new ProjectCommand({
+    pipeline(name, opts) {
+        return new Client({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "projectCommand",
-                    args: Object.assign({}, opts),
+                    operation: "pipeline",
+                    args: Object.assign({ name }, opts),
                 },
             ],
             host: this.clientHost,
@@ -2649,6 +3509,19 @@ export class Client extends BaseClient {
             sessionToken: this.sessionToken,
         });
     }
+    typeDef(opts) {
+        return new TypeDef({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "typeDef",
+                    args: Object.assign({}, opts),
+                },
+            ],
+            host: this.clientHost,
+            sessionToken: this.sessionToken,
+        });
+    }
     /**
      * Call the provided function with current Client.
      *
@@ -2734,3 +3607,211 @@ export class Socket extends BaseClient {
         });
     }
 }
+/**
+ * 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);
+    }
+}