@dagger.io/dagger 0.13.6 → 0.14.0

package/dist/api/client.gen.js

@@ -73,6 +73,24 @@ export var NetworkProtocol;
     NetworkProtocol["Tcp"] = "TCP";
     NetworkProtocol["Udp"] = "UDP";
 })(NetworkProtocol || (NetworkProtocol = {}));
+/**
+ * Expected return type of an execution
+ */
+export var ReturnType;
+(function (ReturnType) {
+    /**
+     * Any execution (exit codes 0-127)
+     */
+    ReturnType["Any"] = "ANY";
+    /**
+     * A failed execution (exit codes 1-127)
+     */
+    ReturnType["Failure"] = "FAILURE";
+    /**
+     * A successful execution (exit code 0)
+     */
+    ReturnType["Success"] = "SUCCESS";
+})(ReturnType || (ReturnType = {}));
 /**
  * Distinguishes the different kinds of TypeDefs.
  */
@@ -163,6 +181,7 @@ export class CacheVolume extends BaseClient {
 export class Container extends BaseClient {
     _id = undefined;
     _envVariable = undefined;
+    _exitCode = undefined;
     _export = undefined;
     _imageRef = undefined;
     _label = undefined;
@@ -177,10 +196,11 @@ export class Container extends BaseClient {
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _id, _envVariable, _export, _imageRef, _label, _platform, _publish, _stderr, _stdout, _sync, _up, _user, _workdir) {
+    constructor(parent, _id, _envVariable, _exitCode, _export, _imageRef, _label, _platform, _publish, _stderr, _stdout, _sync, _up, _user, _workdir) {
         super(parent);
         this._id = _id;
         this._envVariable = _envVariable;
+        this._exitCode = _exitCode;
         this._export = _export;
         this._imageRef = _imageRef;
         this._label = _label;
@@ -359,6 +379,23 @@ export class Container extends BaseClient {
             ctx: this._ctx,
         }, r.id));
     };
+    /**
+     * The exit code of the last executed command.
+     *
+     * Returns an error if no command was set.
+     */
+    exitCode = async () => {
+        if (this._exitCode) {
+            return this._exitCode;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "exitCode",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
     /**
      * EXPERIMENTAL API! Subject to change/removal at any time.
      *
@@ -646,7 +683,7 @@ export class Container extends BaseClient {
     /**
      * The error stream of the last executed command.
      *
-     * Will execute default command if none is set, or error if there's no default.
+     * Returns an error if no command was set.
      */
     stderr = async () => {
         if (this._stderr) {
@@ -663,7 +700,7 @@ export class Container extends BaseClient {
     /**
      * The output stream of the last executed command.
      *
-     * Will execute default command if none is set, or error if there's no default.
+     * Returns an error if no command was set.
      */
     stdout = async () => {
         if (this._stdout) {
@@ -877,6 +914,7 @@ export class Container extends BaseClient {
      * @param opts.stdin Content to write to the command's standard input before closing (e.g., "Hello world").
      * @param opts.redirectStdout Redirect the command's standard output to a file in the container (e.g., "/tmp/stdout").
      * @param opts.redirectStderr Redirect the command's standard error to a file in the container (e.g., "/tmp/stderr").
+     * @param opts.expect Exit codes this command is allowed to exit with without error
      * @param opts.experimentalPrivilegedNesting Provides Dagger access to the executed command.
      *
      * Do not use this option unless you trust the command being executed; the command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST FILESYSTEM.
@@ -887,12 +925,15 @@ export class Container extends BaseClient {
      * This should only be used if the user requires that their exec process be the pid 1 process in the container. Otherwise it may result in unexpected behavior.
      */
     withExec = (args, opts) => {
+        const metadata = {
+            expect: { is_enum: true },
+        };
         return new Container({
             queryTree: [
                 ...this._queryTree,
                 {
                     operation: "withExec",
-                    args: { args, ...opts },
+                    args: { args, ...opts, __metadata: metadata },
                 },
             ],
             ctx: this._ctx,
@@ -974,20 +1015,6 @@ export class Container extends BaseClient {
             ctx: this._ctx,
         });
     };
-    /**
-     * Indicate that subsequent operations should be featured more prominently in the UI.
-     */
-    withFocus = () => {
-        return new Container({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withFocus",
-                },
-            ],
-            ctx: this._ctx,
-        });
-    };
     /**
      * Retrieves this container plus the given label.
      * @param name The name of the label (e.g., "org.opencontainers.artifact.created").
@@ -1414,22 +1441,6 @@ export class Container extends BaseClient {
             ctx: this._ctx,
         });
     };
-    /**
-     * Indicate that subsequent operations should not be featured more prominently in the UI.
-     *
-     * This is the initial state of all containers.
-     */
-    withoutFocus = () => {
-        return new Container({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withoutFocus",
-                },
-            ],
-            ctx: this._ctx,
-        });
-    };
     /**
      * Retrieves this container minus the given environment label.
      * @param name The name of the label to remove (e.g., "org.opencontainers.artifact.created").
@@ -1664,19 +1675,25 @@ export class CurrentModule extends BaseClient {
     };
 }
 /**
- * The Dagger engine configuration and state
+ * A directory.
  */
-export class DaggerEngine extends BaseClient {
+export class Directory extends BaseClient {
     _id = undefined;
+    _digest = undefined;
+    _export = undefined;
+    _sync = undefined;
     /**
      * Constructor is used for internal usage only, do not create object from it.
      */
-    constructor(parent, _id) {
+    constructor(parent, _id, _digest, _export, _sync) {
         super(parent);
         this._id = _id;
+        this._digest = _digest;
+        this._export = _export;
+        this._sync = _sync;
     }
     /**
-     * A unique identifier for this DaggerEngine.
+     * A unique identifier for this Directory.
      */
     id = async () => {
         if (this._id) {
@@ -1691,341 +1708,192 @@ export class DaggerEngine extends BaseClient {
         return response;
     };
     /**
-     * The local (on-disk) cache for the Dagger engine
+     * Load the directory as a Dagger module
+     * @param opts.sourceRootPath An optional subpath of the directory which contains the module's configuration file.
+     *
+     * 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.engineVersion The engine version to upgrade to.
      */
-    localCache = () => {
-        return new DaggerEngineCache({
+    asModule = (opts) => {
+        return new Module_({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "localCache",
+                    operation: "asModule",
+                    args: { ...opts },
                 },
             ],
             ctx: this._ctx,
         });
     };
-}
-/**
- * A cache storage for the Dagger engine
- */
-export class DaggerEngineCache extends BaseClient {
-    _id = undefined;
-    _keepBytes = undefined;
-    _prune = undefined;
-    /**
-     * Constructor is used for internal usage only, do not create object from it.
-     */
-    constructor(parent, _id, _keepBytes, _prune) {
-        super(parent);
-        this._id = _id;
-        this._keepBytes = _keepBytes;
-        this._prune = _prune;
-    }
-    /**
-     * A unique identifier for this DaggerEngineCache.
-     */
-    id = async () => {
-        if (this._id) {
-            return this._id;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "id",
-            },
-        ], await this._ctx.connection());
-        return response;
-    };
     /**
-     * The current set of entries in the cache
+     * Gets the difference between this directory and an another directory.
+     * @param other Identifier of the directory to compare.
      */
-    entrySet = () => {
-        return new DaggerEngineCacheEntrySet({
+    diff = (other) => {
+        return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "entrySet",
+                    operation: "diff",
+                    args: { other },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * The maximum bytes to keep in the cache without pruning, after which automatic pruning may kick in.
+     * Return the directory's digest. The format of the digest is not guaranteed to be stable between releases of Dagger. It is guaranteed to be stable between invocations of the same Dagger engine.
      */
-    keepBytes = async () => {
-        if (this._keepBytes) {
-            return this._keepBytes;
+    digest = async () => {
+        if (this._digest) {
+            return this._digest;
         }
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "keepBytes",
+                operation: "digest",
             },
         ], await this._ctx.connection());
         return response;
     };
     /**
-     * Prune the cache of releaseable entries
+     * Retrieves a directory at the given path.
+     * @param path Location of the directory to retrieve (e.g., "/src").
      */
-    prune = async () => {
-        if (this._prune) {
-            return;
-        }
-        await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "prune",
-            },
-        ], await this._ctx.connection());
+    directory = (path) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "directory",
+                    args: { path },
+                },
+            ],
+            ctx: this._ctx,
+        });
     };
-}
-/**
- * An individual cache entry in a cache entry set
- */
-export class DaggerEngineCacheEntry extends BaseClient {
-    _id = undefined;
-    _activelyUsed = undefined;
-    _createdTimeUnixNano = undefined;
-    _description = undefined;
-    _diskSpaceBytes = undefined;
-    _mostRecentUseTimeUnixNano = undefined;
     /**
-     * Constructor is used for internal usage only, do not create object from it.
+     * Builds a new Docker container from this directory.
+     * @param opts.platform The platform to build.
+     * @param opts.dockerfile Path to the Dockerfile to use (e.g., "frontend.Dockerfile").
+     * @param opts.target Target build stage to build.
+     * @param opts.buildArgs Build arguments to use in the build.
+     * @param opts.secrets Secrets to pass to the build.
+     *
+     * They will be mounted at /run/secrets/[secret-name].
      */
-    constructor(parent, _id, _activelyUsed, _createdTimeUnixNano, _description, _diskSpaceBytes, _mostRecentUseTimeUnixNano) {
-        super(parent);
-        this._id = _id;
-        this._activelyUsed = _activelyUsed;
-        this._createdTimeUnixNano = _createdTimeUnixNano;
-        this._description = _description;
-        this._diskSpaceBytes = _diskSpaceBytes;
-        this._mostRecentUseTimeUnixNano = _mostRecentUseTimeUnixNano;
-    }
+    dockerBuild = (opts) => {
+        return new Container({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "dockerBuild",
+                    args: { ...opts },
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
-     * A unique identifier for this DaggerEngineCacheEntry.
+     * Returns a list of files and directories at the given path.
+     * @param opts.path Location of the directory to look at (e.g., "/src").
      */
-    id = async () => {
-        if (this._id) {
-            return this._id;
-        }
+    entries = async (opts) => {
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "id",
+                operation: "entries",
+                args: { ...opts },
             },
         ], await this._ctx.connection());
         return response;
     };
     /**
-     * Whether the cache entry is actively being used.
+     * Writes the contents of the directory to a path on the host.
+     * @param path Location of the copied directory (e.g., "logs/").
+     * @param opts.wipe If true, then the host directory will be wiped clean before exporting so that it exactly matches the directory being exported; this means it will delete any files on the host that aren't in the exported dir. If false (the default), the contents of the directory will be merged with any existing contents of the host directory, leaving any existing files on the host that aren't in the exported directory alone.
      */
-    activelyUsed = async () => {
-        if (this._activelyUsed) {
-            return this._activelyUsed;
+    export = async (path, opts) => {
+        if (this._export) {
+            return this._export;
         }
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "activelyUsed",
+                operation: "export",
+                args: { path, ...opts },
             },
         ], await this._ctx.connection());
         return response;
     };
     /**
-     * The time the cache entry was created, in Unix nanoseconds.
+     * Retrieves a file at the given path.
+     * @param path Location of the file to retrieve (e.g., "README.md").
      */
-    createdTimeUnixNano = async () => {
-        if (this._createdTimeUnixNano) {
-            return this._createdTimeUnixNano;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "createdTimeUnixNano",
-            },
-        ], await this._ctx.connection());
-        return response;
+    file = (path) => {
+        return new File({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "file",
+                    args: { path },
+                },
+            ],
+            ctx: this._ctx,
+        });
     };
     /**
-     * The description of the cache entry.
+     * Returns a list of files and directories that matche the given pattern.
+     * @param pattern Pattern to match (e.g., "*.md").
      */
-    description = async () => {
-        if (this._description) {
-            return this._description;
-        }
+    glob = async (pattern) => {
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "description",
+                operation: "glob",
+                args: { pattern },
             },
         ], await this._ctx.connection());
         return response;
     };
     /**
-     * The disk space used by the cache entry.
+     * Force evaluation in the engine.
      */
-    diskSpaceBytes = async () => {
-        if (this._diskSpaceBytes) {
-            return this._diskSpaceBytes;
-        }
+    sync = async () => {
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "diskSpaceBytes",
+                operation: "sync",
             },
         ], await this._ctx.connection());
-        return response;
-    };
-    /**
-     * The most recent time the cache entry was used, in Unix nanoseconds.
-     */
-    mostRecentUseTimeUnixNano = async () => {
-        if (this._mostRecentUseTimeUnixNano) {
-            return this._mostRecentUseTimeUnixNano;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "mostRecentUseTimeUnixNano",
-            },
-        ], await this._ctx.connection());
-        return response;
-    };
-}
-/**
- * A set of cache entries returned by a query to a cache
- */
-export class DaggerEngineCacheEntrySet extends BaseClient {
-    _id = undefined;
-    _diskSpaceBytes = undefined;
-    _entryCount = undefined;
-    /**
-     * Constructor is used for internal usage only, do not create object from it.
-     */
-    constructor(parent, _id, _diskSpaceBytes, _entryCount) {
-        super(parent);
-        this._id = _id;
-        this._diskSpaceBytes = _diskSpaceBytes;
-        this._entryCount = _entryCount;
-    }
-    /**
-     * A unique identifier for this DaggerEngineCacheEntrySet.
-     */
-    id = async () => {
-        if (this._id) {
-            return this._id;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "id",
-            },
-        ], await this._ctx.connection());
-        return response;
-    };
-    /**
-     * The total disk space used by the cache entries in this set.
-     */
-    diskSpaceBytes = async () => {
-        if (this._diskSpaceBytes) {
-            return this._diskSpaceBytes;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "diskSpaceBytes",
-            },
-        ], await this._ctx.connection());
-        return response;
-    };
-    /**
-     * The list of individual cache entries in the set
-     */
-    entries = async () => {
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "entries",
-            },
-            {
-                operation: "id",
-            },
-        ], await this._ctx.connection());
-        return response.map((r) => new DaggerEngineCacheEntry({
+        return new Directory({
             queryTree: [
                 {
-                    operation: "loadDaggerEngineCacheEntryFromID",
-                    args: { id: r.id },
+                    operation: "loadDirectoryFromID",
+                    args: { id: response },
                 },
             ],
             ctx: this._ctx,
-        }, r.id));
-    };
-    /**
-     * The number of cache entries in this set.
-     */
-    entryCount = async () => {
-        if (this._entryCount) {
-            return this._entryCount;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "entryCount",
-            },
-        ], await this._ctx.connection());
-        return response;
-    };
-}
-/**
- * A directory.
- */
-export class Directory extends BaseClient {
-    _id = undefined;
-    _digest = undefined;
-    _export = undefined;
-    _sync = undefined;
-    /**
-     * Constructor is used for internal usage only, do not create object from it.
-     */
-    constructor(parent, _id, _digest, _export, _sync) {
-        super(parent);
-        this._id = _id;
-        this._digest = _digest;
-        this._export = _export;
-        this._sync = _sync;
-    }
-    /**
-     * A unique identifier for this Directory.
-     */
-    id = async () => {
-        if (this._id) {
-            return this._id;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "id",
-            },
-        ], await this._ctx.connection());
-        return response;
+        });
     };
     /**
-     * Load the directory as a Dagger module
-     * @param opts.sourceRootPath An optional subpath of the directory which contains the module's configuration file.
-     *
-     * 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.
+     * Opens an interactive terminal in new container with this directory mounted inside.
+     * @param opts.cmd If set, override the container's default terminal command and invoke these command arguments instead.
+     * @param opts.experimentalPrivilegedNesting Provides Dagger access to the executed command.
      *
-     * If not set, the module source code is loaded from the root of the directory.
-     * @param opts.engineVersion The engine version to upgrade to.
+     * Do not use this option unless you trust the command being executed; the command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST FILESYSTEM.
+     * @param opts.insecureRootCapabilities Execute the command with all root capabilities. This is similar to running a command with "sudo" or executing "docker run" with the "--privileged" flag. Containerization does not provide any security guarantees when using this option. It should only be used when absolutely necessary and only with trusted commands.
+     * @param opts.container If set, override the default container used for the terminal.
      */
-    asModule = (opts) => {
-        return new Module_({
+    terminal = (opts) => {
+        return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "asModule",
+                    operation: "terminal",
                     args: { ...opts },
                 },
             ],
@@ -2033,340 +1901,532 @@ export class Directory extends BaseClient {
         });
     };
     /**
-     * Gets the difference between this directory and an another directory.
-     * @param other Identifier of the directory to compare.
+     * Retrieves this directory plus a directory written at the given path.
+     * @param path Location of the written directory (e.g., "/src/").
+     * @param directory Identifier of the directory to copy.
+     * @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.*"]).
      */
-    diff = (other) => {
+    withDirectory = (path, directory, opts) => {
         return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "diff",
-                    args: { other },
+                    operation: "withDirectory",
+                    args: { path, directory, ...opts },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * Return the directory's digest. The format of the digest is not guaranteed to be stable between releases of Dagger. It is guaranteed to be stable between invocations of the same Dagger engine.
-     */
-    digest = async () => {
-        if (this._digest) {
-            return this._digest;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "digest",
-            },
-        ], await this._ctx.connection());
-        return response;
-    };
-    /**
-     * Retrieves a directory at the given path.
-     * @param path Location of the directory to retrieve (e.g., "/src").
+     * Retrieves this directory plus the contents of the given file copied to the given path.
+     * @param path Location of the copied file (e.g., "/file.txt").
+     * @param source Identifier of the file to copy.
+     * @param opts.permissions Permission given to the copied file (e.g., 0600).
      */
-    directory = (path) => {
+    withFile = (path, source, opts) => {
         return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "directory",
-                    args: { path },
+                    operation: "withFile",
+                    args: { path, source, ...opts },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * Builds a new Docker container from this directory.
-     * @param opts.platform The platform to build.
-     * @param opts.dockerfile Path to the Dockerfile to use (e.g., "frontend.Dockerfile").
-     * @param opts.target Target build stage to build.
-     * @param opts.buildArgs Build arguments to use in the build.
-     * @param opts.secrets Secrets to pass to the build.
-     *
-     * They will be mounted at /run/secrets/[secret-name].
+     * Retrieves this directory plus the contents of the given files copied to the given path.
+     * @param path Location where copied files should be placed (e.g., "/src").
+     * @param sources Identifiers of the files to copy.
+     * @param opts.permissions Permission given to the copied files (e.g., 0600).
      */
-    dockerBuild = (opts) => {
-        return new Container({
+    withFiles = (path, sources, opts) => {
+        return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "dockerBuild",
-                    args: { ...opts },
+                    operation: "withFiles",
+                    args: { path, sources, ...opts },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * Returns a list of files and directories at the given path.
-     * @param opts.path Location of the directory to look at (e.g., "/src").
-     */
-    entries = async (opts) => {
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "entries",
-                args: { ...opts },
-            },
-        ], await this._ctx.connection());
-        return response;
-    };
-    /**
-     * Writes the contents of the directory to a path on the host.
-     * @param path Location of the copied directory (e.g., "logs/").
-     * @param opts.wipe If true, then the host directory will be wiped clean before exporting so that it exactly matches the directory being exported; this means it will delete any files on the host that aren't in the exported dir. If false (the default), the contents of the directory will be merged with any existing contents of the host directory, leaving any existing files on the host that aren't in the exported directory alone.
-     */
-    export = async (path, opts) => {
-        if (this._export) {
-            return this._export;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "export",
-                args: { path, ...opts },
-            },
-        ], await this._ctx.connection());
-        return response;
-    };
-    /**
-     * Retrieves a file at the given path.
-     * @param path Location of the file to retrieve (e.g., "README.md").
+     * Retrieves this directory plus a new directory created at the given path.
+     * @param path Location of the directory created (e.g., "/logs").
+     * @param opts.permissions Permission granted to the created directory (e.g., 0777).
      */
-    file = (path) => {
-        return new File({
+    withNewDirectory = (path, opts) => {
+        return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "file",
-                    args: { path },
+                    operation: "withNewDirectory",
+                    args: { path, ...opts },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * Returns a list of files and directories that matche the given pattern.
-     * @param pattern Pattern to match (e.g., "*.md").
+     * Retrieves this directory plus a new file written at the given path.
+     * @param path Location of the written file (e.g., "/file.txt").
+     * @param contents Content of the written file (e.g., "Hello world!").
+     * @param opts.permissions Permission given to the copied file (e.g., 0600).
      */
-    glob = async (pattern) => {
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "glob",
-                args: { pattern },
-            },
-        ], await this._ctx.connection());
-        return response;
-    };
-    /**
-     * Force evaluation in the engine.
-     */
-    sync = async () => {
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "sync",
-            },
-        ], await this._ctx.connection());
+    withNewFile = (path, contents, opts) => {
         return new Directory({
             queryTree: [
+                ...this._queryTree,
                 {
-                    operation: "loadDirectoryFromID",
-                    args: { id: response },
+                    operation: "withNewFile",
+                    args: { path, contents, ...opts },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * Opens an interactive terminal in new container with this directory mounted inside.
-     * @param opts.cmd If set, override the container's default terminal command and invoke these command arguments instead.
-     * @param opts.experimentalPrivilegedNesting Provides Dagger access to the executed command.
+     * Retrieves this directory with all file/dir timestamps set to the given time.
+     * @param timestamp Timestamp to set dir/files in.
      *
-     * Do not use this option unless you trust the command being executed; the command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST FILESYSTEM.
-     * @param opts.insecureRootCapabilities Execute the command with all root capabilities. This is similar to running a command with "sudo" or executing "docker run" with the "--privileged" flag. Containerization does not provide any security guarantees when using this option. It should only be used when absolutely necessary and only with trusted commands.
-     * @param opts.container If set, override the default container used for the terminal.
+     * Formatted in seconds following Unix epoch (e.g., 1672531199).
      */
-    terminal = (opts) => {
+    withTimestamps = (timestamp) => {
         return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "terminal",
-                    args: { ...opts },
+                    operation: "withTimestamps",
+                    args: { timestamp },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * Retrieves this directory plus a directory written at the given path.
-     * @param path Location of the written directory (e.g., "/src/").
-     * @param directory Identifier of the directory to copy.
-     * @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.*"]).
+     * Retrieves this directory with the directory at the given path removed.
+     * @param path Location of the directory to remove (e.g., ".github/").
      */
-    withDirectory = (path, directory, opts) => {
+    withoutDirectory = (path) => {
         return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "withDirectory",
-                    args: { path, directory, ...opts },
+                    operation: "withoutDirectory",
+                    args: { path },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * Retrieves this directory plus the contents of the given file copied to the given path.
-     * @param path Location of the copied file (e.g., "/file.txt").
-     * @param source Identifier of the file to copy.
-     * @param opts.permissions Permission given to the copied file (e.g., 0600).
+     * Retrieves this directory with the file at the given path removed.
+     * @param path Location of the file to remove (e.g., "/file.txt").
      */
-    withFile = (path, source, opts) => {
+    withoutFile = (path) => {
         return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "withFile",
-                    args: { path, source, ...opts },
+                    operation: "withoutFile",
+                    args: { path },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * Retrieves this directory plus the contents of the given files copied to the given path.
-     * @param path Location where copied files should be placed (e.g., "/src").
-     * @param sources Identifiers of the files to copy.
-     * @param opts.permissions Permission given to the copied files (e.g., 0600).
+     * Retrieves this directory with the files at the given paths removed.
+     * @param paths Location of the file to remove (e.g., ["/file.txt"]).
      */
-    withFiles = (path, sources, opts) => {
+    withoutFiles = (paths) => {
         return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "withFiles",
-                    args: { path, sources, ...opts },
+                    operation: "withoutFiles",
+                    args: { paths },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * Retrieves this directory plus a new directory created at the given path.
-     * @param path Location of the directory created (e.g., "/logs").
-     * @param opts.permissions Permission granted to the created directory (e.g., 0777).
+     * Call the provided function with current Directory.
+     *
+     * This is useful for reusability and readability by not breaking the calling chain.
      */
-    withNewDirectory = (path, opts) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withNewDirectory",
-                    args: { path, ...opts },
-                },
-            ],
-            ctx: this._ctx,
-        });
+    with = (arg) => {
+        return arg(this);
+    };
+}
+/**
+ * The Dagger engine configuration and state
+ */
+export class Engine extends BaseClient {
+    _id = undefined;
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _id) {
+        super(parent);
+        this._id = _id;
+    }
+    /**
+     * A unique identifier for this Engine.
+     */
+    id = async () => {
+        if (this._id) {
+            return this._id;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "id",
+            },
+        ], await this._ctx.connection());
+        return response;
     };
     /**
-     * Retrieves this directory plus a new file written at the given path.
-     * @param path Location of the written file (e.g., "/file.txt").
-     * @param contents Content of the written file (e.g., "Hello world!").
-     * @param opts.permissions Permission given to the copied file (e.g., 0600).
+     * The local (on-disk) cache for the Dagger engine
      */
-    withNewFile = (path, contents, opts) => {
-        return new Directory({
+    localCache = () => {
+        return new EngineCache({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "withNewFile",
-                    args: { path, contents, ...opts },
+                    operation: "localCache",
                 },
             ],
             ctx: this._ctx,
         });
     };
+}
+/**
+ * A cache storage for the Dagger engine
+ */
+export class EngineCache extends BaseClient {
+    _id = undefined;
+    _keepBytes = undefined;
+    _maxUsedSpace = undefined;
+    _minFreeSpace = undefined;
+    _prune = undefined;
+    _reservedSpace = undefined;
     /**
-     * Retrieves this directory with all file/dir timestamps set to the given time.
-     * @param timestamp Timestamp to set dir/files in.
-     *
-     * Formatted in seconds following Unix epoch (e.g., 1672531199).
+     * Constructor is used for internal usage only, do not create object from it.
      */
-    withTimestamps = (timestamp) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withTimestamps",
-                    args: { timestamp },
-                },
-            ],
-            ctx: this._ctx,
-        });
+    constructor(parent, _id, _keepBytes, _maxUsedSpace, _minFreeSpace, _prune, _reservedSpace) {
+        super(parent);
+        this._id = _id;
+        this._keepBytes = _keepBytes;
+        this._maxUsedSpace = _maxUsedSpace;
+        this._minFreeSpace = _minFreeSpace;
+        this._prune = _prune;
+        this._reservedSpace = _reservedSpace;
+    }
+    /**
+     * A unique identifier for this EngineCache.
+     */
+    id = async () => {
+        if (this._id) {
+            return this._id;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "id",
+            },
+        ], await this._ctx.connection());
+        return response;
     };
     /**
-     * Retrieves this directory with the directory at the given path removed.
-     * @param path Location of the directory to remove (e.g., ".github/").
+     * The current set of entries in the cache
      */
-    withoutDirectory = (path) => {
-        return new Directory({
+    entrySet = () => {
+        return new EngineCacheEntrySet({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "withoutDirectory",
-                    args: { path },
+                    operation: "entrySet",
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * Retrieves this directory with the file at the given path removed.
-     * @param path Location of the file to remove (e.g., "/file.txt").
+     * The maximum bytes to keep in the cache without pruning, after which automatic pruning may kick in.
+     * @deprecated Use minFreeSpace instead.
+     */
+    keepBytes = async () => {
+        if (this._keepBytes) {
+            return this._keepBytes;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "keepBytes",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The maximum bytes to keep in the cache without pruning.
+     */
+    maxUsedSpace = async () => {
+        if (this._maxUsedSpace) {
+            return this._maxUsedSpace;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "maxUsedSpace",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The target amount of free disk space the garbage collector will attempt to leave.
+     */
+    minFreeSpace = async () => {
+        if (this._minFreeSpace) {
+            return this._minFreeSpace;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "minFreeSpace",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * Prune the cache of releaseable entries
+     */
+    prune = async () => {
+        if (this._prune) {
+            return;
+        }
+        await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "prune",
+            },
+        ], await this._ctx.connection());
+    };
+    reservedSpace = async () => {
+        if (this._reservedSpace) {
+            return this._reservedSpace;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "reservedSpace",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+}
+/**
+ * An individual cache entry in a cache entry set
+ */
+export class EngineCacheEntry extends BaseClient {
+    _id = undefined;
+    _activelyUsed = undefined;
+    _createdTimeUnixNano = undefined;
+    _description = undefined;
+    _diskSpaceBytes = undefined;
+    _mostRecentUseTimeUnixNano = undefined;
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _id, _activelyUsed, _createdTimeUnixNano, _description, _diskSpaceBytes, _mostRecentUseTimeUnixNano) {
+        super(parent);
+        this._id = _id;
+        this._activelyUsed = _activelyUsed;
+        this._createdTimeUnixNano = _createdTimeUnixNano;
+        this._description = _description;
+        this._diskSpaceBytes = _diskSpaceBytes;
+        this._mostRecentUseTimeUnixNano = _mostRecentUseTimeUnixNano;
+    }
+    /**
+     * A unique identifier for this EngineCacheEntry.
+     */
+    id = async () => {
+        if (this._id) {
+            return this._id;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "id",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * Whether the cache entry is actively being used.
+     */
+    activelyUsed = async () => {
+        if (this._activelyUsed) {
+            return this._activelyUsed;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "activelyUsed",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The time the cache entry was created, in Unix nanoseconds.
+     */
+    createdTimeUnixNano = async () => {
+        if (this._createdTimeUnixNano) {
+            return this._createdTimeUnixNano;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "createdTimeUnixNano",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The description of the cache entry.
+     */
+    description = async () => {
+        if (this._description) {
+            return this._description;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "description",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The disk space used by the cache entry.
+     */
+    diskSpaceBytes = async () => {
+        if (this._diskSpaceBytes) {
+            return this._diskSpaceBytes;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "diskSpaceBytes",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The most recent time the cache entry was used, in Unix nanoseconds.
+     */
+    mostRecentUseTimeUnixNano = async () => {
+        if (this._mostRecentUseTimeUnixNano) {
+            return this._mostRecentUseTimeUnixNano;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "mostRecentUseTimeUnixNano",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+}
+/**
+ * A set of cache entries returned by a query to a cache
+ */
+export class EngineCacheEntrySet extends BaseClient {
+    _id = undefined;
+    _diskSpaceBytes = undefined;
+    _entryCount = undefined;
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _id, _diskSpaceBytes, _entryCount) {
+        super(parent);
+        this._id = _id;
+        this._diskSpaceBytes = _diskSpaceBytes;
+        this._entryCount = _entryCount;
+    }
+    /**
+     * A unique identifier for this EngineCacheEntrySet.
+     */
+    id = async () => {
+        if (this._id) {
+            return this._id;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "id",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The total disk space used by the cache entries in this set.
      */
-    withoutFile = (path) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withoutFile",
-                    args: { path },
-                },
-            ],
-            ctx: this._ctx,
-        });
+    diskSpaceBytes = async () => {
+        if (this._diskSpaceBytes) {
+            return this._diskSpaceBytes;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "diskSpaceBytes",
+            },
+        ], await this._ctx.connection());
+        return response;
     };
     /**
-     * Retrieves this directory with the files at the given paths removed.
-     * @param paths Location of the file to remove (e.g., ["/file.txt"]).
+     * The list of individual cache entries in the set
      */
-    withoutFiles = (paths) => {
-        return new Directory({
+    entries = async () => {
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "entries",
+            },
+            {
+                operation: "id",
+            },
+        ], await this._ctx.connection());
+        return response.map((r) => new EngineCacheEntry({
             queryTree: [
-                ...this._queryTree,
                 {
-                    operation: "withoutFiles",
-                    args: { paths },
+                    operation: "loadEngineCacheEntryFromID",
+                    args: { id: r.id },
                 },
             ],
             ctx: this._ctx,
-        });
+        }, r.id));
     };
     /**
-     * Call the provided function with current Directory.
-     *
-     * This is useful for reusability and readability by not breaking the calling chain.
+     * The number of cache entries in this set.
      */
-    with = (arg) => {
-        return arg(this);
+    entryCount = async () => {
+        if (this._entryCount) {
+            return this._entryCount;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "entryCount",
+            },
+        ], await this._ctx.connection());
+        return response;
     };
 }
 /**
@@ -2432,6 +2492,20 @@ export class EnumTypeDef extends BaseClient {
         ], await this._ctx.connection());
         return response;
     };
+    /**
+     * The location of this enum declaration.
+     */
+    sourceMap = () => {
+        return new SourceMap({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "sourceMap",
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
      * If this EnumTypeDef is associated with a Module, the name of the module. Unset otherwise.
      */
@@ -2532,6 +2606,20 @@ export class EnumValueTypeDef extends BaseClient {
         ], await this._ctx.connection());
         return response;
     };
+    /**
+     * The location of this enum value declaration.
+     */
+    sourceMap = () => {
+        return new SourceMap({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "sourceMap",
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
 }
 /**
  * An environment variable name and value.
@@ -2658,6 +2746,20 @@ export class FieldTypeDef extends BaseClient {
         ], await this._ctx.connection());
         return response;
     };
+    /**
+     * The location of this field declaration.
+     */
+    sourceMap = () => {
+        return new SourceMap({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "sourceMap",
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
      * The type of the field.
      */
@@ -2955,6 +3057,20 @@ export class Function_ extends BaseClient {
             ctx: this._ctx,
         });
     };
+    /**
+     * The location of this function declaration.
+     */
+    sourceMap = () => {
+        return new SourceMap({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "sourceMap",
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
      * Returns the function with the provided argument
      * @param name The name of the argument
@@ -2992,6 +3108,22 @@ export class Function_ extends BaseClient {
             ctx: this._ctx,
         });
     };
+    /**
+     * Returns the function with the given source map.
+     * @param sourceMap The source map for the function definition.
+     */
+    withSourceMap = (sourceMap) => {
+        return new Function_({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withSourceMap",
+                    args: { sourceMap },
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
      * Call the provided function with current Function.
      *
@@ -3110,6 +3242,20 @@ export class FunctionArg extends BaseClient {
         ], await this._ctx.connection());
         return response;
     };
+    /**
+     * The location of this arg declaration.
+     */
+    sourceMap = () => {
+        return new SourceMap({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "sourceMap",
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
      * The type of the argument.
      */
@@ -4094,6 +4240,20 @@ export class InterfaceTypeDef extends BaseClient {
         ], await this._ctx.connection());
         return response;
     };
+    /**
+     * The location of this interface declaration.
+     */
+    sourceMap = () => {
+        return new SourceMap({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "sourceMap",
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
      * If this InterfaceTypeDef is associated with a Module, the name of the module. Unset otherwise.
      */
@@ -5385,6 +5545,20 @@ export class ObjectTypeDef extends BaseClient {
         ], await this._ctx.connection());
         return response;
     };
+    /**
+     * The location of this object declaration.
+     */
+    sourceMap = () => {
+        return new SourceMap({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "sourceMap",
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
      * If this ObjectTypeDef is associated with a Module, the name of the module. Unset otherwise.
      */
@@ -5639,20 +5813,6 @@ export class Client extends BaseClient {
             ctx: this._ctx,
         }, r.id));
     };
-    /**
-     * The Dagger engine container configuration and state
-     */
-    daggerEngine = () => {
-        return new DaggerEngine({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "daggerEngine",
-                },
-            ],
-            ctx: this._ctx,
-        });
-    };
     /**
      * The default platform of the engine.
      */
@@ -5679,6 +5839,20 @@ export class Client extends BaseClient {
             ctx: this._ctx,
         });
     };
+    /**
+     * The Dagger engine container configuration and state
+     */
+    engine = () => {
+        return new Engine({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "engine",
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
      * Creates a function.
      * @param name Name of the function, in its original format from the implementation language.
@@ -5812,14 +5986,14 @@ export class Client extends BaseClient {
         });
     };
     /**
-     * Load a DaggerEngineCacheEntry from its ID.
+     * Load a Directory from its ID.
      */
-    loadDaggerEngineCacheEntryFromID = (id) => {
-        return new DaggerEngineCacheEntry({
+    loadDirectoryFromID = (id) => {
+        return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "loadDaggerEngineCacheEntryFromID",
+                    operation: "loadDirectoryFromID",
                     args: { id },
                 },
             ],
@@ -5827,14 +6001,14 @@ export class Client extends BaseClient {
         });
     };
     /**
-     * Load a DaggerEngineCacheEntrySet from its ID.
+     * Load a EngineCacheEntry from its ID.
      */
-    loadDaggerEngineCacheEntrySetFromID = (id) => {
-        return new DaggerEngineCacheEntrySet({
+    loadEngineCacheEntryFromID = (id) => {
+        return new EngineCacheEntry({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "loadDaggerEngineCacheEntrySetFromID",
+                    operation: "loadEngineCacheEntryFromID",
                     args: { id },
                 },
             ],
@@ -5842,14 +6016,14 @@ export class Client extends BaseClient {
         });
     };
     /**
-     * Load a DaggerEngineCache from its ID.
+     * Load a EngineCacheEntrySet from its ID.
      */
-    loadDaggerEngineCacheFromID = (id) => {
-        return new DaggerEngineCache({
+    loadEngineCacheEntrySetFromID = (id) => {
+        return new EngineCacheEntrySet({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "loadDaggerEngineCacheFromID",
+                    operation: "loadEngineCacheEntrySetFromID",
                     args: { id },
                 },
             ],
@@ -5857,14 +6031,14 @@ export class Client extends BaseClient {
         });
     };
     /**
-     * Load a DaggerEngine from its ID.
+     * Load a EngineCache from its ID.
      */
-    loadDaggerEngineFromID = (id) => {
-        return new DaggerEngine({
+    loadEngineCacheFromID = (id) => {
+        return new EngineCache({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "loadDaggerEngineFromID",
+                    operation: "loadEngineCacheFromID",
                     args: { id },
                 },
             ],
@@ -5872,14 +6046,14 @@ export class Client extends BaseClient {
         });
     };
     /**
-     * Load a Directory from its ID.
+     * Load a Engine from its ID.
      */
-    loadDirectoryFromID = (id) => {
-        return new Directory({
+    loadEngineFromID = (id) => {
+        return new Engine({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "loadDirectoryFromID",
+                    operation: "loadEngineFromID",
                     args: { id },
                 },
             ],
@@ -6321,6 +6495,21 @@ export class Client extends BaseClient {
             ctx: this._ctx,
         });
     };
+    /**
+     * Load a SourceMap from its ID.
+     */
+    loadSourceMapFromID = (id) => {
+        return new SourceMap({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "loadSourceMapFromID",
+                    args: { id },
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
      * Load a Terminal from its ID.
      */
@@ -6435,6 +6624,24 @@ export class Client extends BaseClient {
             ctx: this._ctx,
         });
     };
+    /**
+     * Creates source map metadata.
+     * @param filename The filename from the module source.
+     * @param line The line number within the filename.
+     * @param column The column number within the line.
+     */
+    sourceMap = (filename, line, column) => {
+        return new SourceMap({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "sourceMap",
+                    args: { filename, line, column },
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
      * Create a new TypeDef.
      */
@@ -6816,6 +7023,102 @@ export class Socket extends BaseClient {
         return response;
     };
 }
+/**
+ * Source location information.
+ */
+export class SourceMap extends BaseClient {
+    _id = undefined;
+    _column = undefined;
+    _filename = undefined;
+    _line = undefined;
+    _module = undefined;
+    /**
+     * Constructor is used for internal usage only, do not create object from it.
+     */
+    constructor(parent, _id, _column, _filename, _line, _module) {
+        super(parent);
+        this._id = _id;
+        this._column = _column;
+        this._filename = _filename;
+        this._line = _line;
+        this._module = _module;
+    }
+    /**
+     * A unique identifier for this SourceMap.
+     */
+    id = async () => {
+        if (this._id) {
+            return this._id;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "id",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The column number within the line.
+     */
+    column = async () => {
+        if (this._column) {
+            return this._column;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "column",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The filename from the module source.
+     */
+    filename = async () => {
+        if (this._filename) {
+            return this._filename;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "filename",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The line number within the filename.
+     */
+    line = async () => {
+        if (this._line) {
+            return this._line;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "line",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+    /**
+     * The module dependency this was declared in.
+     */
+    module_ = async () => {
+        if (this._module) {
+            return this._module;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "module",
+            },
+        ], await this._ctx.connection());
+        return response;
+    };
+}
 /**
  * An interactive terminal that clients can connect to.
  */
@@ -7036,6 +7339,7 @@ export class TypeDef extends BaseClient {
      * Note that an enum's values may be omitted if the intent is only to refer to an enum. This is how functions are able to return their own, or any other circular reference.
      * @param name The name of the enum
      * @param opts.description A doc string for the enum, if any
+     * @param opts.sourceMap The source map for the enum definition.
      */
     withEnum = (name, opts) => {
         return new TypeDef({
@@ -7053,6 +7357,7 @@ export class TypeDef extends BaseClient {
      * Adds a static value for an Enum TypeDef, failing if the type is not an enum.
      * @param value The name of the value in the enum
      * @param opts.description A doc string for the value, if any
+     * @param opts.sourceMap The source map for the enum value definition.
      */
     withEnumValue = (value, opts) => {
         return new TypeDef({
@@ -7071,6 +7376,7 @@ export class TypeDef extends BaseClient {
      * @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
+     * @param opts.sourceMap The source map for the field definition.
      */
     withField = (name, typeDef, opts) => {
         return new TypeDef({