@dagger.io/dagger 0.13.7 → 0.14.0

package/dist/api/client.gen.js

@@ -1015,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").
@@ -1455,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").
@@ -1705,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) {
@@ -1732,362 +1708,377 @@ 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;
-    _maxUsedSpace = undefined;
-    _minFreeSpace = undefined;
-    _prune = undefined;
-    _reservedSpace = undefined;
     /**
-     * Constructor is used for internal usage only, do not create object from it.
+     * Gets the difference between this directory and an another directory.
+     * @param other Identifier of the directory to compare.
      */
-    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;
-    }
+    diff = (other) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "diff",
+                    args: { other },
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
-     * A unique identifier for this DaggerEngineCache.
+     * 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.
      */
-    id = async () => {
-        if (this._id) {
-            return this._id;
+    digest = async () => {
+        if (this._digest) {
+            return this._digest;
         }
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "id",
+                operation: "digest",
             },
         ], await this._ctx.connection());
         return response;
     };
     /**
-     * The current set of entries in the cache
+     * Retrieves a directory at the given path.
+     * @param path Location of the directory to retrieve (e.g., "/src").
      */
-    entrySet = () => {
-        return new DaggerEngineCacheEntrySet({
+    directory = (path) => {
+        return new Directory({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "entrySet",
+                    operation: "directory",
+                    args: { path },
                 },
             ],
             ctx: this._ctx,
         });
     };
     /**
-     * The maximum bytes to keep in the cache without pruning, after which automatic pruning may kick in.
-     * @deprecated Use minFreeSpace instead.
+     * 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].
      */
-    keepBytes = async () => {
-        if (this._keepBytes) {
-            return this._keepBytes;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "keepBytes",
-            },
-        ], await this._ctx.connection());
-        return response;
+    dockerBuild = (opts) => {
+        return new Container({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "dockerBuild",
+                    args: { ...opts },
+                },
+            ],
+            ctx: this._ctx,
+        });
     };
     /**
-     * The maximum bytes to keep in the cache without pruning.
+     * Returns a list of files and directories at the given path.
+     * @param opts.path Location of the directory to look at (e.g., "/src").
      */
-    maxUsedSpace = async () => {
-        if (this._maxUsedSpace) {
-            return this._maxUsedSpace;
-        }
+    entries = async (opts) => {
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "maxUsedSpace",
+                operation: "entries",
+                args: { ...opts },
             },
         ], await this._ctx.connection());
         return response;
     };
     /**
-     * The target amount of free disk space the garbage collector will attempt to leave.
+     * 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.
      */
-    minFreeSpace = async () => {
-        if (this._minFreeSpace) {
-            return this._minFreeSpace;
+    export = async (path, opts) => {
+        if (this._export) {
+            return this._export;
         }
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "minFreeSpace",
+                operation: "export",
+                args: { path, ...opts },
             },
         ], await this._ctx.connection());
         return response;
     };
     /**
-     * Prune the cache of releaseable entries
+     * Retrieves a file at the given path.
+     * @param path Location of the file to retrieve (e.g., "README.md").
      */
-    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;
+    file = (path) => {
+        return new File({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "file",
+                    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.
-     */
-    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 DaggerEngineCacheEntry.
+     * Returns a list of files and directories that matche the given pattern.
+     * @param pattern Pattern to match (e.g., "*.md").
      */
-    id = async () => {
-        if (this._id) {
-            return this._id;
-        }
+    glob = async (pattern) => {
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "id",
+                operation: "glob",
+                args: { pattern },
             },
         ], await this._ctx.connection());
         return response;
     };
     /**
-     * Whether the cache entry is actively being used.
+     * Force evaluation in the engine.
      */
-    activelyUsed = async () => {
-        if (this._activelyUsed) {
-            return this._activelyUsed;
-        }
+    sync = async () => {
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "activelyUsed",
+                operation: "sync",
             },
         ], await this._ctx.connection());
-        return response;
+        return new Directory({
+            queryTree: [
+                {
+                    operation: "loadDirectoryFromID",
+                    args: { id: response },
+                },
+            ],
+            ctx: this._ctx,
+        });
     };
     /**
-     * The time the cache entry was created, in Unix nanoseconds.
+     * 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.
+     *
+     * 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.
      */
-    createdTimeUnixNano = async () => {
-        if (this._createdTimeUnixNano) {
-            return this._createdTimeUnixNano;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "createdTimeUnixNano",
-            },
-        ], await this._ctx.connection());
-        return response;
+    terminal = (opts) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "terminal",
+                    args: { ...opts },
+                },
+            ],
+            ctx: this._ctx,
+        });
     };
     /**
-     * The description of the cache entry.
+     * 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.*"]).
      */
-    description = async () => {
-        if (this._description) {
-            return this._description;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "description",
-            },
-        ], await this._ctx.connection());
-        return response;
+    withDirectory = (path, directory, opts) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withDirectory",
+                    args: { path, directory, ...opts },
+                },
+            ],
+            ctx: this._ctx,
+        });
     };
     /**
-     * The disk space used by the cache entry.
+     * 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).
      */
-    diskSpaceBytes = async () => {
-        if (this._diskSpaceBytes) {
-            return this._diskSpaceBytes;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "diskSpaceBytes",
-            },
-        ], await this._ctx.connection());
-        return response;
+    withFile = (path, source, opts) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withFile",
+                    args: { path, source, ...opts },
+                },
+            ],
+            ctx: this._ctx,
+        });
     };
     /**
-     * The most recent time the cache entry was used, in Unix nanoseconds.
+     * 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).
      */
-    mostRecentUseTimeUnixNano = async () => {
-        if (this._mostRecentUseTimeUnixNano) {
-            return this._mostRecentUseTimeUnixNano;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "mostRecentUseTimeUnixNano",
-            },
-        ], await this._ctx.connection());
-        return response;
+    withFiles = (path, sources, opts) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withFiles",
+                    args: { path, sources, ...opts },
+                },
+            ],
+            ctx: this._ctx,
+        });
     };
-}
-/**
- * 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.
+     * 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).
      */
-    constructor(parent, _id, _diskSpaceBytes, _entryCount) {
-        super(parent);
-        this._id = _id;
-        this._diskSpaceBytes = _diskSpaceBytes;
-        this._entryCount = _entryCount;
-    }
+    withNewDirectory = (path, opts) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withNewDirectory",
+                    args: { path, ...opts },
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
     /**
-     * A unique identifier for this DaggerEngineCacheEntrySet.
+     * 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).
      */
-    id = async () => {
-        if (this._id) {
-            return this._id;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "id",
-            },
-        ], await this._ctx.connection());
-        return response;
+    withNewFile = (path, contents, opts) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withNewFile",
+                    args: { path, contents, ...opts },
+                },
+            ],
+            ctx: this._ctx,
+        });
     };
     /**
-     * The total disk space used by the cache entries in this set.
+     * 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).
      */
-    diskSpaceBytes = async () => {
-        if (this._diskSpaceBytes) {
-            return this._diskSpaceBytes;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "diskSpaceBytes",
-            },
-        ], await this._ctx.connection());
-        return response;
+    withTimestamps = (timestamp) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withTimestamps",
+                    args: { timestamp },
+                },
+            ],
+            ctx: this._ctx,
+        });
     };
     /**
-     * The list of individual cache entries in the set
+     * Retrieves this directory with the directory at the given path removed.
+     * @param path Location of the directory to remove (e.g., ".github/").
      */
-    entries = async () => {
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "entries",
-            },
-            {
-                operation: "id",
-            },
-        ], await this._ctx.connection());
-        return response.map((r) => new DaggerEngineCacheEntry({
+    withoutDirectory = (path) => {
+        return new Directory({
             queryTree: [
+                ...this._queryTree,
                 {
-                    operation: "loadDaggerEngineCacheEntryFromID",
-                    args: { id: r.id },
+                    operation: "withoutDirectory",
+                    args: { path },
                 },
             ],
             ctx: this._ctx,
-        }, r.id));
+        });
     };
     /**
-     * The number of cache entries in this set.
+     * Retrieves this directory with the file at the given path removed.
+     * @param path Location of the file to remove (e.g., "/file.txt").
      */
-    entryCount = async () => {
-        if (this._entryCount) {
-            return this._entryCount;
-        }
-        const response = await computeQuery([
-            ...this._queryTree,
-            {
-                operation: "entryCount",
-            },
-        ], await this._ctx.connection());
-        return response;
+    withoutFile = (path) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withoutFile",
+                    args: { path },
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
+    /**
+     * Retrieves this directory with the files at the given paths removed.
+     * @param paths Location of the file to remove (e.g., ["/file.txt"]).
+     */
+    withoutFiles = (paths) => {
+        return new Directory({
+            queryTree: [
+                ...this._queryTree,
+                {
+                    operation: "withoutFiles",
+                    args: { paths },
+                },
+            ],
+            ctx: this._ctx,
+        });
+    };
+    /**
+     * Call the provided function with current Directory.
+     *
+     * This is useful for reusability and readability by not breaking the calling chain.
+     */
+    with = (arg) => {
+        return arg(this);
     };
 }
 /**
- * A directory.
+ * The Dagger engine configuration and state
  */
-export class Directory extends BaseClient {
+export class Engine 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) {
+    constructor(parent, _id) {
         super(parent);
         this._id = _id;
-        this._digest = _digest;
-        this._export = _export;
-        this._sync = _sync;
     }
     /**
-     * A unique identifier for this Directory.
+     * A unique identifier for this Engine.
      */
     id = async () => {
         if (this._id) {
@@ -2102,361 +2093,340 @@ export class Directory extends BaseClient {
         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.
-     *
-     * If not set, the module source code is loaded from the root of the directory.
-     * @param opts.engineVersion The engine version to upgrade to.
+     * The local (on-disk) cache for the Dagger engine
      */
-    asModule = (opts) => {
-        return new Module_({
+    localCache = () => {
+        return new EngineCache({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "asModule",
-                    args: { ...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;
     /**
-     * Gets the difference between this directory and an another directory.
-     * @param other Identifier of the directory to compare.
+     * Constructor is used for internal usage only, do not create object from it.
      */
-    diff = (other) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "diff",
-                    args: { other },
-                },
-            ],
-            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;
+    }
     /**
-     * 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.
+     * A unique identifier for this EngineCache.
      */
-    digest = async () => {
-        if (this._digest) {
-            return this._digest;
+    id = async () => {
+        if (this._id) {
+            return this._id;
         }
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "digest",
+                operation: "id",
             },
         ], await this._ctx.connection());
         return response;
     };
     /**
-     * Retrieves a directory at the given path.
-     * @param path Location of the directory to retrieve (e.g., "/src").
+     * The current set of entries in the cache
      */
-    directory = (path) => {
-        return new Directory({
+    entrySet = () => {
+        return new EngineCacheEntrySet({
             queryTree: [
                 ...this._queryTree,
                 {
-                    operation: "directory",
-                    args: { path },
+                    operation: "entrySet",
                 },
             ],
             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].
+     * The maximum bytes to keep in the cache without pruning, after which automatic pruning may kick in.
+     * @deprecated Use minFreeSpace instead.
      */
-    dockerBuild = (opts) => {
-        return new Container({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "dockerBuild",
-                    args: { ...opts },
-                },
-            ],
-            ctx: this._ctx,
-        });
+    keepBytes = async () => {
+        if (this._keepBytes) {
+            return this._keepBytes;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "keepBytes",
+            },
+        ], await this._ctx.connection());
+        return response;
     };
     /**
-     * Returns a list of files and directories at the given path.
-     * @param opts.path Location of the directory to look at (e.g., "/src").
+     * The maximum bytes to keep in the cache without pruning.
      */
-    entries = async (opts) => {
+    maxUsedSpace = async () => {
+        if (this._maxUsedSpace) {
+            return this._maxUsedSpace;
+        }
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "entries",
-                args: { ...opts },
+                operation: "maxUsedSpace",
             },
         ], 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.
+     * The target amount of free disk space the garbage collector will attempt to leave.
      */
-    export = async (path, opts) => {
-        if (this._export) {
-            return this._export;
+    minFreeSpace = async () => {
+        if (this._minFreeSpace) {
+            return this._minFreeSpace;
         }
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "export",
-                args: { path, ...opts },
+                operation: "minFreeSpace",
             },
         ], 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").
+     * Prune the cache of releaseable entries
      */
-    file = (path) => {
-        return new File({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "file",
-                    args: { path },
-                },
-            ],
-            ctx: this._ctx,
-        });
+    prune = async () => {
+        if (this._prune) {
+            return;
+        }
+        await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "prune",
+            },
+        ], await this._ctx.connection());
     };
-    /**
-     * Returns a list of files and directories that matche the given pattern.
-     * @param pattern Pattern to match (e.g., "*.md").
-     */
-    glob = async (pattern) => {
+    reservedSpace = async () => {
+        if (this._reservedSpace) {
+            return this._reservedSpace;
+        }
         const response = await computeQuery([
             ...this._queryTree,
             {
-                operation: "glob",
-                args: { pattern },
+                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;
     /**
-     * Force evaluation in the engine.
+     * Constructor is used for internal usage only, do not create object from it.
      */
-    sync = async () => {
+    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: "sync",
+                operation: "id",
             },
         ], await this._ctx.connection());
-        return new Directory({
-            queryTree: [
-                {
-                    operation: "loadDirectoryFromID",
-                    args: { id: response },
-                },
-            ],
-            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.
-     *
-     * 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.
-     */
-    terminal = (opts) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "terminal",
-                    args: { ...opts },
-                },
-            ],
-            ctx: this._ctx,
-        });
+        return response;
     };
     /**
-     * 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.*"]).
+     * Whether the cache entry is actively being used.
      */
-    withDirectory = (path, directory, opts) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withDirectory",
-                    args: { path, directory, ...opts },
-                },
-            ],
-            ctx: this._ctx,
-        });
+    activelyUsed = async () => {
+        if (this._activelyUsed) {
+            return this._activelyUsed;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "activelyUsed",
+            },
+        ], await this._ctx.connection());
+        return response;
     };
     /**
-     * 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).
+     * The time the cache entry was created, in Unix nanoseconds.
      */
-    withFile = (path, source, opts) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withFile",
-                    args: { path, source, ...opts },
-                },
-            ],
-            ctx: this._ctx,
-        });
+    createdTimeUnixNano = async () => {
+        if (this._createdTimeUnixNano) {
+            return this._createdTimeUnixNano;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "createdTimeUnixNano",
+            },
+        ], await this._ctx.connection());
+        return response;
     };
     /**
-     * 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).
+     * The description of the cache entry.
      */
-    withFiles = (path, sources, opts) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withFiles",
-                    args: { path, sources, ...opts },
-                },
-            ],
-            ctx: this._ctx,
-        });
+    description = async () => {
+        if (this._description) {
+            return this._description;
+        }
+        const response = await computeQuery([
+            ...this._queryTree,
+            {
+                operation: "description",
+            },
+        ], await this._ctx.connection());
+        return response;
     };
     /**
-     * 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).
+     * The disk space used by the cache entry.
      */
-    withNewDirectory = (path, opts) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withNewDirectory",
-                    args: { path, ...opts },
-                },
-            ],
-            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 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 most recent time the cache entry was used, in Unix nanoseconds.
      */
-    withNewFile = (path, contents, opts) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withNewFile",
-                    args: { path, contents, ...opts },
-                },
-            ],
-            ctx: this._ctx,
-        });
+    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;
     /**
-     * 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, _diskSpaceBytes, _entryCount) {
+        super(parent);
+        this._id = _id;
+        this._diskSpaceBytes = _diskSpaceBytes;
+        this._entryCount = _entryCount;
+    }
     /**
-     * Retrieves this directory with the directory at the given path removed.
-     * @param path Location of the directory to remove (e.g., ".github/").
+     * A unique identifier for this EngineCacheEntrySet.
      */
-    withoutDirectory = (path) => {
-        return new Directory({
-            queryTree: [
-                ...this._queryTree,
-                {
-                    operation: "withoutDirectory",
-                    args: { path },
-                },
-            ],
-            ctx: this._ctx,
-        });
+    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 file at the given path removed.
-     * @param path Location of the file to remove (e.g., "/file.txt").
+     * 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;
     };
 }
 /**
@@ -5843,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.
      */
@@ -5883,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.
@@ -6016,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 },
                 },
             ],
@@ -6031,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 },
                 },
             ],
@@ -6046,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 },
                 },
             ],
@@ -6061,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 },
                 },
             ],
@@ -6076,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 },
                 },
             ],