diff --git a/crates/dagger-codegen/src/rust/templates/enum_tmpl.rs b/crates/dagger-codegen/src/rust/templates/enum_tmpl.rs
index e0df6c9..965ca9a 100644
--- a/crates/dagger-codegen/src/rust/templates/enum_tmpl.rs
+++ b/crates/dagger-codegen/src/rust/templates/enum_tmpl.rs
@@ -1,6 +1,7 @@
 use dagger_core::introspection::FullType;
 use genco::prelude::rust;
 use genco::quote;
+use itertools::Itertools;
 
 fn render_enum_values(values: &FullType) -> Option<rust::Tokens> {
     let values = values
@@ -10,6 +11,7 @@ fn render_enum_values(values: &FullType) -> Option<rust::Tokens> {
         .map(|values| {
             values
                 .into_iter()
+                .sorted_by_key(|a| &a.name)
                 .map(|val| quote! { $(val.name.as_ref()), })
         })
         .flatten()
diff --git a/crates/dagger-sdk/src/gen.rs b/crates/dagger-sdk/src/gen.rs
index 85ad27b..696ffe7 100644
--- a/crates/dagger-sdk/src/gen.rs
+++ b/crates/dagger-sdk/src/gen.rs
@@ -106,8 +106,8 @@ impl Into<SocketId> for String {
 }
 #[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
 pub struct BuildArg {
-    pub name: String,
     pub value: String,
+    pub name: String,
 }
 #[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
 pub struct PipelineLabel {
@@ -122,8 +122,10 @@ pub struct CacheVolume {
 }
 
 impl CacheVolume {
-    pub async fn id(&self) -> eyre::Result<CacheId> {
-        let query = self.selection.select("id");
+    pub async fn id(
+        &self,
+    ) -> eyre::Result<CacheId> {
+        let mut query = self.selection.select("id");
 
         query.execute(&graphql_client(&self.conn)).await
     }
@@ -137,6 +139,7 @@ pub struct Container {
 
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerBuildOpts<'a> {
+
     /// Path to the Dockerfile to use.
     /// Default: './Dockerfile'.
     #[builder(setter(into, strip_option), default)]
@@ -150,6 +153,7 @@ pub struct ContainerBuildOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerEndpointOpts<'a> {
+
     /// The exposed port number for the endpoint
     #[builder(setter(into, strip_option), default)]
     pub port: Option<isize>,
@@ -159,6 +163,7 @@ pub struct ContainerEndpointOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerExecOpts<'a> {
+
     /// Command to run instead of the container's default command (e.g., ["run", "main.go"]).
     #[builder(setter(into, strip_option), default)]
     pub args: Option<Vec<&'a str>>,
@@ -179,6 +184,7 @@ pub struct ContainerExecOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerExportOpts {
+
     /// Identifiers for other platform specific containers.
     /// Used for multi-platform image.
     #[builder(setter(into, strip_option), default)]
@@ -186,6 +192,7 @@ pub struct ContainerExportOpts {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerPipelineOpts<'a> {
+
     /// Pipeline description.
     #[builder(setter(into, strip_option), default)]
     pub description: Option<&'a str>,
@@ -195,6 +202,7 @@ pub struct ContainerPipelineOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerPublishOpts {
+
     /// Identifiers for other platform specific containers.
     /// Used for multi-platform image.
     #[builder(setter(into, strip_option), default)]
@@ -202,12 +210,14 @@ pub struct ContainerPublishOpts {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithDefaultArgsOpts<'a> {
+
     /// Arguments to prepend to future executions (e.g., ["-v", "--no-cache"]).
     #[builder(setter(into, strip_option), default)]
     pub args: Option<Vec<&'a str>>,
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithDirectoryOpts<'a> {
+
     /// Patterns to exclude in the written directory (e.g., ["node_modules/**", ".gitignore", ".git/"]).
     #[builder(setter(into, strip_option), default)]
     pub exclude: Option<Vec<&'a str>>,
@@ -217,6 +227,7 @@ pub struct ContainerWithDirectoryOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithExecOpts<'a> {
+
     /// Content to write to the command's standard input before closing (e.g., "Hello world").
     #[builder(setter(into, strip_option), default)]
     pub stdin: Option<&'a str>,
@@ -240,6 +251,7 @@ pub struct ContainerWithExecOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithExposedPortOpts<'a> {
+
     /// Transport layer network protocol
     #[builder(setter(into, strip_option), default)]
     pub protocol: Option<NetworkProtocol>,
@@ -249,6 +261,7 @@ pub struct ContainerWithExposedPortOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithFileOpts {
+
     /// Permission given to the copied file (e.g., 0600).
     /// Default: 0644.
     #[builder(setter(into, strip_option), default)]
@@ -256,6 +269,7 @@ pub struct ContainerWithFileOpts {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithMountedCacheOpts {
+
     /// Identifier of the directory to use as the cache volume's root.
     #[builder(setter(into, strip_option), default)]
     pub source: Option<DirectoryId>,
@@ -265,6 +279,7 @@ pub struct ContainerWithMountedCacheOpts {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithNewFileOpts<'a> {
+
     /// Content of the file to write (e.g., "Hello world!").
     #[builder(setter(into, strip_option), default)]
     pub contents: Option<&'a str>,
@@ -275,6 +290,7 @@ pub struct ContainerWithNewFileOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithoutExposedPortOpts {
+
     /// Port protocol to unexpose
     #[builder(setter(into, strip_option), default)]
     pub protocol: Option<NetworkProtocol>,
@@ -282,12 +298,15 @@ pub struct ContainerWithoutExposedPortOpts {
 
 impl Container {
     /// Initializes this container from a Dockerfile build.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `context` - Directory context used by the Dockerfile.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn build(&self, context: DirectoryId) -> Container {
+    pub fn build(
+        &self,
+        context: DirectoryId,
+    ) -> Container {
         let mut query = self.selection.select("build");
 
         query = query.arg("context", context);
@@ -296,16 +315,20 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Initializes this container from a Dockerfile build.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `context` - Directory context used by the Dockerfile.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn build_opts<'a>(&self, context: DirectoryId, opts: ContainerBuildOpts<'a>) -> Container {
+    pub fn build_opts<'a>(
+        &self,
+        context: DirectoryId,
+        opts: ContainerBuildOpts<'a>
+    ) -> Container {
         let mut query = self.selection.select("build");
 
         query = query.arg("context", context);
@@ -323,21 +346,26 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves default arguments for future commands.
-    pub async fn default_args(&self) -> eyre::Result<Vec<String>> {
-        let query = self.selection.select("defaultArgs");
+    pub async fn default_args(
+        &self,
+    ) -> eyre::Result<Vec<String>> {
+        let mut query = self.selection.select("defaultArgs");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves a directory at the given path.
     /// Mounts are included.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - The path of the directory to retrieve (e.g., "./src").
-    pub fn directory(&self, path: impl Into<String>) -> Directory {
+    pub fn directory(
+        &self,
+        path: impl Into<String>,
+    ) -> Directory {
         let mut query = self.selection.select("directory");
 
         query = query.arg("path", path.into());
@@ -346,18 +374,20 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves an endpoint that clients can use to reach this container.
     /// If no port is specified, the first exposed port is used. If none exist an error is returned.
     /// If a scheme is specified, a URL is returned. Otherwise, a host:port pair is returned.
     /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub async fn endpoint(&self) -> eyre::Result<String> {
-        let query = self.selection.select("endpoint");
+    pub async fn endpoint(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("endpoint");
 
         query.execute(&graphql_client(&self.conn)).await
     }
@@ -366,11 +396,14 @@ impl Container {
     /// If no port is specified, the first exposed port is used. If none exist an error is returned.
     /// If a scheme is specified, a URL is returned. Otherwise, a host:port pair is returned.
     /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub async fn endpoint_opts<'a>(&self, opts: ContainerEndpointOpts<'a>) -> eyre::Result<String> {
+    pub async fn endpoint_opts<'a>(
+        &self,
+        opts: ContainerEndpointOpts<'a>
+    ) -> eyre::Result<String> {
         let mut query = self.selection.select("endpoint");
 
         if let Some(port) = opts.port {
@@ -383,17 +416,22 @@ impl Container {
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves entrypoint to be prepended to the arguments of all commands.
-    pub async fn entrypoint(&self) -> eyre::Result<Vec<String>> {
-        let query = self.selection.select("entrypoint");
+    pub async fn entrypoint(
+        &self,
+    ) -> eyre::Result<Vec<String>> {
+        let mut query = self.selection.select("entrypoint");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves the value of the specified environment variable.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - The name of the environment variable to retrieve (e.g., "PATH").
-    pub async fn env_variable(&self, name: impl Into<String>) -> eyre::Result<String> {
+    pub async fn env_variable(
+        &self,
+        name: impl Into<String>,
+    ) -> eyre::Result<String> {
         let mut query = self.selection.select("envVariable");
 
         query = query.arg("name", name.into());
@@ -401,36 +439,43 @@ impl Container {
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves the list of environment variables passed to commands.
-    pub fn env_variables(&self) -> Vec<EnvVariable> {
-        let query = self.selection.select("envVariables");
+    pub fn env_variables(
+        &self,
+    ) -> Vec<EnvVariable> {
+        let mut query = self.selection.select("envVariables");
 
         return vec![EnvVariable {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        }];
+        }]
     }
     /// Retrieves this container after executing the specified command inside it.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn exec(&self) -> Container {
-        let query = self.selection.select("exec");
+    pub fn exec(
+        &self,
+    ) -> Container {
+        let mut query = self.selection.select("exec");
 
         return Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves this container after executing the specified command inside it.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn exec_opts<'a>(&self, opts: ContainerExecOpts<'a>) -> Container {
+    pub fn exec_opts<'a>(
+        &self,
+        opts: ContainerExecOpts<'a>
+    ) -> Container {
         let mut query = self.selection.select("exec");
 
         if let Some(args) = opts.args {
@@ -446,35 +491,37 @@ impl Container {
             query = query.arg("redirectStderr", redirect_stderr);
         }
         if let Some(experimental_privileged_nesting) = opts.experimental_privileged_nesting {
-            query = query.arg(
-                "experimentalPrivilegedNesting",
-                experimental_privileged_nesting,
-            );
+            query = query.arg("experimentalPrivilegedNesting", experimental_privileged_nesting);
         }
 
         return Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Exit code of the last executed command. Zero means success.
     /// Errors if no command has been executed.
-    pub async fn exit_code(&self) -> eyre::Result<isize> {
-        let query = self.selection.select("exitCode");
+    pub async fn exit_code(
+        &self,
+    ) -> eyre::Result<isize> {
+        let mut query = self.selection.select("exitCode");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Writes the container as an OCI tarball to the destination file path on the host for the specified platform variants.
     /// Return true on success.
     /// It can also publishes platform variants.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Host's destination path (e.g., "./tarball").
     /// Path can be relative to the engine's workdir or absolute.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub async fn export(&self, path: impl Into<String>) -> eyre::Result<bool> {
+    pub async fn export(
+        &self,
+        path: impl Into<String>,
+    ) -> eyre::Result<bool> {
         let mut query = self.selection.select("export");
 
         query = query.arg("path", path.into());
@@ -485,16 +532,16 @@ impl Container {
     /// Writes the container as an OCI tarball to the destination file path on the host for the specified platform variants.
     /// Return true on success.
     /// It can also publishes platform variants.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Host's destination path (e.g., "./tarball").
     /// Path can be relative to the engine's workdir or absolute.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub async fn export_opts(
         &self,
         path: impl Into<String>,
-        opts: ContainerExportOpts,
+        opts: ContainerExportOpts
     ) -> eyre::Result<bool> {
         let mut query = self.selection.select("export");
 
@@ -507,22 +554,27 @@ impl Container {
     }
     /// Retrieves the list of exposed ports.
     /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-    pub fn exposed_ports(&self) -> Vec<Port> {
-        let query = self.selection.select("exposedPorts");
+    pub fn exposed_ports(
+        &self,
+    ) -> Vec<Port> {
+        let mut query = self.selection.select("exposedPorts");
 
         return vec![Port {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        }];
+        }]
     }
     /// Retrieves a file at the given path.
     /// Mounts are included.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - The path of the file to retrieve (e.g., "./README.md").
-    pub fn file(&self, path: impl Into<String>) -> File {
+    pub fn file(
+        &self,
+        path: impl Into<String>,
+    ) -> File {
         let mut query = self.selection.select("file");
 
         query = query.arg("path", path.into());
@@ -531,16 +583,19 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Initializes this container from a pulled base image.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `address` - Image's address from its registry.
-    ///
+    /// 
     /// Formatted as [host]/[user]/[repo]:[tag] (e.g., "docker.io/dagger/dagger:main").
-    pub fn from(&self, address: impl Into<String>) -> Container {
+    pub fn from(
+        &self,
+        address: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("from");
 
         query = query.arg("address", address.into());
@@ -549,39 +604,50 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container's root filesystem. Mounts are not included.
-    pub fn fs(&self) -> Directory {
-        let query = self.selection.select("fs");
+    pub fn fs(
+        &self,
+    ) -> Directory {
+        let mut query = self.selection.select("fs");
 
         return Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves a hostname which can be used by clients to reach this container.
     /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-    pub async fn hostname(&self) -> eyre::Result<String> {
-        let query = self.selection.select("hostname");
+    pub async fn hostname(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("hostname");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// A unique identifier for this container.
-    pub async fn id(&self) -> eyre::Result<ContainerId> {
-        let query = self.selection.select("id");
+    pub async fn id(
+        &self,
+    ) -> eyre::Result<ContainerId> {
+        let mut query = self.selection.select("id");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// The unique image reference which can only be retrieved immediately after the 'Container.From' call.
-    pub async fn image_ref(&self) -> eyre::Result<String> {
-        let query = self.selection.select("imageRef");
+    pub async fn image_ref(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("imageRef");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves the value of the specified label.
-    pub async fn label(&self, name: impl Into<String>) -> eyre::Result<String> {
+    pub async fn label(
+        &self,
+        name: impl Into<String>,
+    ) -> eyre::Result<String> {
         let mut query = self.selection.select("label");
 
         query = query.arg("name", name.into());
@@ -589,28 +655,35 @@ impl Container {
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves the list of labels passed to container.
-    pub fn labels(&self) -> Vec<Label> {
-        let query = self.selection.select("labels");
+    pub fn labels(
+        &self,
+    ) -> Vec<Label> {
+        let mut query = self.selection.select("labels");
 
         return vec![Label {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        }];
+        }]
     }
     /// Retrieves the list of paths where a directory is mounted.
-    pub async fn mounts(&self) -> eyre::Result<Vec<String>> {
-        let query = self.selection.select("mounts");
+    pub async fn mounts(
+        &self,
+    ) -> eyre::Result<Vec<String>> {
+        let mut query = self.selection.select("mounts");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Creates a named sub-pipeline
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - Pipeline name.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn pipeline(&self, name: impl Into<String>) -> Container {
+    pub fn pipeline(
+        &self,
+        name: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("pipeline");
 
         query = query.arg("name", name.into());
@@ -619,19 +692,19 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Creates a named sub-pipeline
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - Pipeline name.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub fn pipeline_opts<'a>(
         &self,
         name: impl Into<String>,
-        opts: ContainerPipelineOpts<'a>,
+        opts: ContainerPipelineOpts<'a>
     ) -> Container {
         let mut query = self.selection.select("pipeline");
 
@@ -647,25 +720,30 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// The platform this container executes and publishes as.
-    pub async fn platform(&self) -> eyre::Result<Platform> {
-        let query = self.selection.select("platform");
+    pub async fn platform(
+        &self,
+    ) -> eyre::Result<Platform> {
+        let mut query = self.selection.select("platform");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Publishes this container as a new image to the specified address.
     /// Publish returns a fully qualified ref.
     /// It can also publish platform variants.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `address` - Registry's address to publish the image to.
-    ///
+    /// 
     /// Formatted as [host]/[user]/[repo]:[tag] (e.g. "docker.io/dagger/dagger:main").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub async fn publish(&self, address: impl Into<String>) -> eyre::Result<String> {
+    pub async fn publish(
+        &self,
+        address: impl Into<String>,
+    ) -> eyre::Result<String> {
         let mut query = self.selection.select("publish");
 
         query = query.arg("address", address.into());
@@ -676,17 +754,17 @@ impl Container {
     /// Publishes this container as a new image to the specified address.
     /// Publish returns a fully qualified ref.
     /// It can also publish platform variants.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `address` - Registry's address to publish the image to.
-    ///
+    /// 
     /// Formatted as [host]/[user]/[repo]:[tag] (e.g. "docker.io/dagger/dagger:main").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub async fn publish_opts(
         &self,
         address: impl Into<String>,
-        opts: ContainerPublishOpts,
+        opts: ContainerPublishOpts
     ) -> eyre::Result<String> {
         let mut query = self.selection.select("publish");
 
@@ -698,56 +776,69 @@ impl Container {
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves this container's root filesystem. Mounts are not included.
-    pub fn rootfs(&self) -> Directory {
-        let query = self.selection.select("rootfs");
+    pub fn rootfs(
+        &self,
+    ) -> Directory {
+        let mut query = self.selection.select("rootfs");
 
         return Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// The error stream of the last executed command.
     /// Errors if no command has been executed.
-    pub async fn stderr(&self) -> eyre::Result<String> {
-        let query = self.selection.select("stderr");
+    pub async fn stderr(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("stderr");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// The output stream of the last executed command.
     /// Errors if no command has been executed.
-    pub async fn stdout(&self) -> eyre::Result<String> {
-        let query = self.selection.select("stdout");
+    pub async fn stdout(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("stdout");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves the user to be set for all commands.
-    pub async fn user(&self) -> eyre::Result<String> {
-        let query = self.selection.select("user");
+    pub async fn user(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("user");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Configures default arguments for future commands.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_default_args(&self) -> Container {
-        let query = self.selection.select("withDefaultArgs");
+    pub fn with_default_args(
+        &self,
+    ) -> Container {
+        let mut query = self.selection.select("withDefaultArgs");
 
         return Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Configures default arguments for future commands.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_default_args_opts<'a>(&self, opts: ContainerWithDefaultArgsOpts<'a>) -> Container {
+    pub fn with_default_args_opts<'a>(
+        &self,
+        opts: ContainerWithDefaultArgsOpts<'a>
+    ) -> Container {
         let mut query = self.selection.select("withDefaultArgs");
 
         if let Some(args) = opts.args {
@@ -758,16 +849,20 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus a directory written at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the written directory (e.g., "/tmp/directory").
     /// * `directory` - Identifier of the directory to write
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_directory(&self, path: impl Into<String>, directory: DirectoryId) -> Container {
+    pub fn with_directory(
+        &self,
+        path: impl Into<String>,
+        directory: DirectoryId,
+    ) -> Container {
         let mut query = self.selection.select("withDirectory");
 
         query = query.arg("path", path.into());
@@ -777,13 +872,13 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves this container plus a directory written at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the written directory (e.g., "/tmp/directory").
     /// * `directory` - Identifier of the directory to write
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
@@ -791,7 +886,7 @@ impl Container {
         &self,
         path: impl Into<String>,
         directory: DirectoryId,
-        opts: ContainerWithDirectoryOpts<'a>,
+        opts: ContainerWithDirectoryOpts<'a>
     ) -> Container {
         let mut query = self.selection.select("withDirectory");
 
@@ -808,31 +903,31 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container but with a different command entrypoint.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `args` - Entrypoint to use for future executions (e.g., ["go", "run"]).
-    pub fn with_entrypoint(&self, args: Vec<impl Into<String>>) -> Container {
+    pub fn with_entrypoint(
+        &self,
+        args: Vec<impl Into<String>>,
+    ) -> Container {
         let mut query = self.selection.select("withEntrypoint");
 
-        query = query.arg(
-            "args",
-            args.into_iter().map(|i| i.into()).collect::<Vec<String>>(),
-        );
+        query = query.arg("args", args.into_iter().map(|i| i.into()).collect::<Vec<String>>());
 
         return Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus the given environment variable.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - The name of the environment variable (e.g., "HOST").
     /// * `value` - The value of the environment variable. (e.g., "localhost").
     pub fn with_env_variable(
@@ -849,46 +944,43 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container after executing the specified command inside it.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `args` - Command to run instead of the container's default command (e.g., ["run", "main.go"]).
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_exec(&self, args: Vec<impl Into<String>>) -> Container {
+    pub fn with_exec(
+        &self,
+        args: Vec<impl Into<String>>,
+    ) -> Container {
         let mut query = self.selection.select("withExec");
 
-        query = query.arg(
-            "args",
-            args.into_iter().map(|i| i.into()).collect::<Vec<String>>(),
-        );
+        query = query.arg("args", args.into_iter().map(|i| i.into()).collect::<Vec<String>>());
 
         return Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves this container after executing the specified command inside it.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `args` - Command to run instead of the container's default command (e.g., ["run", "main.go"]).
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub fn with_exec_opts<'a>(
         &self,
         args: Vec<impl Into<String>>,
-        opts: ContainerWithExecOpts<'a>,
+        opts: ContainerWithExecOpts<'a>
     ) -> Container {
         let mut query = self.selection.select("withExec");
 
-        query = query.arg(
-            "args",
-            args.into_iter().map(|i| i.into()).collect::<Vec<String>>(),
-        );
+        query = query.arg("args", args.into_iter().map(|i| i.into()).collect::<Vec<String>>());
         if let Some(stdin) = opts.stdin {
             query = query.arg("stdin", stdin);
         }
@@ -899,10 +991,7 @@ impl Container {
             query = query.arg("redirectStderr", redirect_stderr);
         }
         if let Some(experimental_privileged_nesting) = opts.experimental_privileged_nesting {
-            query = query.arg(
-                "experimentalPrivilegedNesting",
-                experimental_privileged_nesting,
-            );
+            query = query.arg("experimentalPrivilegedNesting", experimental_privileged_nesting);
         }
         if let Some(insecure_root_capabilities) = opts.insecure_root_capabilities {
             query = query.arg("insecureRootCapabilities", insecure_root_capabilities);
@@ -912,19 +1001,22 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Expose a network port.
     /// Exposed ports serve two purposes:
     /// - For health checks and introspection, when running services
     /// - For setting the EXPOSE OCI field when publishing the container
     /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `port` - Port number to expose
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_exposed_port(&self, port: isize) -> Container {
+    pub fn with_exposed_port(
+        &self,
+        port: isize,
+    ) -> Container {
         let mut query = self.selection.select("withExposedPort");
 
         query = query.arg("port", port);
@@ -933,7 +1025,7 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Expose a network port.
@@ -941,15 +1033,15 @@ impl Container {
     /// - For health checks and introspection, when running services
     /// - For setting the EXPOSE OCI field when publishing the container
     /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `port` - Port number to expose
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub fn with_exposed_port_opts<'a>(
         &self,
         port: isize,
-        opts: ContainerWithExposedPortOpts<'a>,
+        opts: ContainerWithExposedPortOpts<'a>
     ) -> Container {
         let mut query = self.selection.select("withExposedPort");
 
@@ -965,10 +1057,13 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Initializes this container from this DirectoryID.
-    pub fn with_fs(&self, id: DirectoryId) -> Container {
+    pub fn with_fs(
+        &self,
+        id: DirectoryId,
+    ) -> Container {
         let mut query = self.selection.select("withFS");
 
         query = query.arg("id", id);
@@ -977,16 +1072,20 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus the contents of the given file copied to the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the copied file (e.g., "/tmp/file.txt").
     /// * `source` - Identifier of the file to copy.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_file(&self, path: impl Into<String>, source: FileId) -> Container {
+    pub fn with_file(
+        &self,
+        path: impl Into<String>,
+        source: FileId,
+    ) -> Container {
         let mut query = self.selection.select("withFile");
 
         query = query.arg("path", path.into());
@@ -996,13 +1095,13 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves this container plus the contents of the given file copied to the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the copied file (e.g., "/tmp/file.txt").
     /// * `source` - Identifier of the file to copy.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
@@ -1010,7 +1109,7 @@ impl Container {
         &self,
         path: impl Into<String>,
         source: FileId,
-        opts: ContainerWithFileOpts,
+        opts: ContainerWithFileOpts
     ) -> Container {
         let mut query = self.selection.select("withFile");
 
@@ -1024,15 +1123,19 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus the given label.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - The name of the label (e.g., "org.opencontainers.artifact.created").
     /// * `value` - The value of the label (e.g., "2023-01-01T00:00:00Z").
-    pub fn with_label(&self, name: impl Into<String>, value: impl Into<String>) -> Container {
+    pub fn with_label(
+        &self,
+        name: impl Into<String>,
+        value: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("withLabel");
 
         query = query.arg("name", name.into());
@@ -1042,16 +1145,20 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus a cache volume mounted at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the cache directory (e.g., "/cache/node_modules").
     /// * `cache` - Identifier of the cache volume to mount.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_mounted_cache(&self, path: impl Into<String>, cache: CacheId) -> Container {
+    pub fn with_mounted_cache(
+        &self,
+        path: impl Into<String>,
+        cache: CacheId,
+    ) -> Container {
         let mut query = self.selection.select("withMountedCache");
 
         query = query.arg("path", path.into());
@@ -1061,13 +1168,13 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves this container plus a cache volume mounted at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the cache directory (e.g., "/cache/node_modules").
     /// * `cache` - Identifier of the cache volume to mount.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
@@ -1075,7 +1182,7 @@ impl Container {
         &self,
         path: impl Into<String>,
         cache: CacheId,
-        opts: ContainerWithMountedCacheOpts,
+        opts: ContainerWithMountedCacheOpts
     ) -> Container {
         let mut query = self.selection.select("withMountedCache");
 
@@ -1092,12 +1199,12 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus a directory mounted at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the mounted directory (e.g., "/mnt/directory").
     /// * `source` - Identifier of the mounted directory.
     pub fn with_mounted_directory(
@@ -1114,15 +1221,19 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus a file mounted at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the mounted file (e.g., "/tmp/file.txt").
     /// * `source` - Identifier of the mounted file.
-    pub fn with_mounted_file(&self, path: impl Into<String>, source: FileId) -> Container {
+    pub fn with_mounted_file(
+        &self,
+        path: impl Into<String>,
+        source: FileId,
+    ) -> Container {
         let mut query = self.selection.select("withMountedFile");
 
         query = query.arg("path", path.into());
@@ -1132,15 +1243,19 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus a secret mounted into a file at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the secret file (e.g., "/tmp/secret.txt").
     /// * `source` - Identifier of the secret to mount.
-    pub fn with_mounted_secret(&self, path: impl Into<String>, source: SecretId) -> Container {
+    pub fn with_mounted_secret(
+        &self,
+        path: impl Into<String>,
+        source: SecretId,
+    ) -> Container {
         let mut query = self.selection.select("withMountedSecret");
 
         query = query.arg("path", path.into());
@@ -1150,14 +1265,17 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus a temporary directory mounted at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the temporary directory (e.g., "/tmp/temp_dir").
-    pub fn with_mounted_temp(&self, path: impl Into<String>) -> Container {
+    pub fn with_mounted_temp(
+        &self,
+        path: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("withMountedTemp");
 
         query = query.arg("path", path.into());
@@ -1166,15 +1284,18 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus a new file written at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the written file (e.g., "/tmp/file.txt").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_new_file(&self, path: impl Into<String>) -> Container {
+    pub fn with_new_file(
+        &self,
+        path: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("withNewFile");
 
         query = query.arg("path", path.into());
@@ -1183,19 +1304,19 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves this container plus a new file written at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the written file (e.g., "/tmp/file.txt").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub fn with_new_file_opts<'a>(
         &self,
         path: impl Into<String>,
-        opts: ContainerWithNewFileOpts<'a>,
+        opts: ContainerWithNewFileOpts<'a>
     ) -> Container {
         let mut query = self.selection.select("withNewFile");
 
@@ -1211,12 +1332,12 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container with a registry authentication for a given address.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `address` - Registry's address to bind the authentication to.
     /// Formatted as [host]/[user]/[repo]:[tag] (e.g. docker.io/dagger/dagger:main).
     /// * `username` - The username of the registry's account (e.g., "Dagger").
@@ -1237,10 +1358,13 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Initializes this container from this DirectoryID.
-    pub fn with_rootfs(&self, id: DirectoryId) -> Container {
+    pub fn with_rootfs(
+        &self,
+        id: DirectoryId,
+    ) -> Container {
         let mut query = self.selection.select("withRootfs");
 
         query = query.arg("id", id);
@@ -1249,15 +1373,19 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus an env variable containing the given secret.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - The name of the secret variable (e.g., "API_SECRET").
     /// * `secret` - The identifier of the secret value.
-    pub fn with_secret_variable(&self, name: impl Into<String>, secret: SecretId) -> Container {
+    pub fn with_secret_variable(
+        &self,
+        name: impl Into<String>,
+        secret: SecretId,
+    ) -> Container {
         let mut query = self.selection.select("withSecretVariable");
 
         query = query.arg("name", name.into());
@@ -1267,15 +1395,15 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Establish a runtime dependency on a service. The service will be started automatically when needed and detached when it is no longer needed.
     /// The service will be reachable from the container via the provided hostname alias.
     /// The service dependency will also convey to any files or directories produced by the container.
     /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `alias` - A name that can be used to reach the service from the container
     /// * `service` - Identifier of the service container
     pub fn with_service_binding(
@@ -1292,15 +1420,19 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container plus a socket forwarded to the given Unix socket path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the forwarded Unix socket (e.g., "/tmp/socket").
     /// * `source` - Identifier of the socket to forward.
-    pub fn with_unix_socket(&self, path: impl Into<String>, source: SocketId) -> Container {
+    pub fn with_unix_socket(
+        &self,
+        path: impl Into<String>,
+        source: SocketId,
+    ) -> Container {
         let mut query = self.selection.select("withUnixSocket");
 
         query = query.arg("path", path.into());
@@ -1310,14 +1442,17 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container with a different command user.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - The user to set (e.g., "root").
-    pub fn with_user(&self, name: impl Into<String>) -> Container {
+    pub fn with_user(
+        &self,
+        name: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("withUser");
 
         query = query.arg("name", name.into());
@@ -1326,14 +1461,17 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container with a different working directory.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - The path to set as the working directory (e.g., "/app").
-    pub fn with_workdir(&self, path: impl Into<String>) -> Container {
+    pub fn with_workdir(
+        &self,
+        path: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("withWorkdir");
 
         query = query.arg("path", path.into());
@@ -1342,14 +1480,17 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container minus the given environment variable.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - The name of the environment variable (e.g., "HOST").
-    pub fn without_env_variable(&self, name: impl Into<String>) -> Container {
+    pub fn without_env_variable(
+        &self,
+        name: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("withoutEnvVariable");
 
         query = query.arg("name", name.into());
@@ -1358,16 +1499,19 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Unexpose a previously exposed port.
     /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `port` - Port number to unexpose
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn without_exposed_port(&self, port: isize) -> Container {
+    pub fn without_exposed_port(
+        &self,
+        port: isize,
+    ) -> Container {
         let mut query = self.selection.select("withoutExposedPort");
 
         query = query.arg("port", port);
@@ -1376,20 +1520,20 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Unexpose a previously exposed port.
     /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `port` - Port number to unexpose
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub fn without_exposed_port_opts(
         &self,
         port: isize,
-        opts: ContainerWithoutExposedPortOpts,
+        opts: ContainerWithoutExposedPortOpts
     ) -> Container {
         let mut query = self.selection.select("withoutExposedPort");
 
@@ -1402,14 +1546,17 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container minus the given environment label.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - The name of the label to remove (e.g., "org.opencontainers.artifact.created").
-    pub fn without_label(&self, name: impl Into<String>) -> Container {
+    pub fn without_label(
+        &self,
+        name: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("withoutLabel");
 
         query = query.arg("name", name.into());
@@ -1418,14 +1565,17 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container after unmounting everything at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the cache directory (e.g., "/cache/node_modules").
-    pub fn without_mount(&self, path: impl Into<String>) -> Container {
+    pub fn without_mount(
+        &self,
+        path: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("withoutMount");
 
         query = query.arg("path", path.into());
@@ -1434,15 +1584,18 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container without the registry authentication of a given address.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `address` - Registry's address to remove the authentication from.
     /// Formatted as [host]/[user]/[repo]:[tag] (e.g. docker.io/dagger/dagger:main).
-    pub fn without_registry_auth(&self, address: impl Into<String>) -> Container {
+    pub fn without_registry_auth(
+        &self,
+        address: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("withoutRegistryAuth");
 
         query = query.arg("address", address.into());
@@ -1451,14 +1604,17 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this container with a previously added Unix socket removed.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the socket to remove (e.g., "/tmp/socket").
-    pub fn without_unix_socket(&self, path: impl Into<String>) -> Container {
+    pub fn without_unix_socket(
+        &self,
+        path: impl Into<String>,
+    ) -> Container {
         let mut query = self.selection.select("withoutUnixSocket");
 
         query = query.arg("path", path.into());
@@ -1467,11 +1623,13 @@ impl Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves the working directory for all commands.
-    pub async fn workdir(&self) -> eyre::Result<String> {
-        let query = self.selection.select("workdir");
+    pub async fn workdir(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("workdir");
 
         query.execute(&graphql_client(&self.conn)).await
     }
@@ -1485,6 +1643,7 @@ pub struct Directory {
 
 #[derive(Builder, Debug, PartialEq)]
 pub struct DirectoryDockerBuildOpts<'a> {
+
     /// Path to the Dockerfile to use (e.g., "frontend.Dockerfile").
     /// Defaults: './Dockerfile'.
     #[builder(setter(into, strip_option), default)]
@@ -1501,12 +1660,14 @@ pub struct DirectoryDockerBuildOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct DirectoryEntriesOpts<'a> {
+
     /// Location of the directory to look at (e.g., "/src").
     #[builder(setter(into, strip_option), default)]
     pub path: Option<&'a str>,
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct DirectoryPipelineOpts<'a> {
+
     /// Pipeline description.
     #[builder(setter(into, strip_option), default)]
     pub description: Option<&'a str>,
@@ -1516,6 +1677,7 @@ pub struct DirectoryPipelineOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct DirectoryWithDirectoryOpts<'a> {
+
     /// Exclude artifacts that match the given pattern (e.g., ["node_modules/", ".git*"]).
     #[builder(setter(into, strip_option), default)]
     pub exclude: Option<Vec<&'a str>>,
@@ -1525,6 +1687,7 @@ pub struct DirectoryWithDirectoryOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct DirectoryWithFileOpts {
+
     /// Permission given to the copied file (e.g., 0600).
     /// Default: 0644.
     #[builder(setter(into, strip_option), default)]
@@ -1532,6 +1695,7 @@ pub struct DirectoryWithFileOpts {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct DirectoryWithNewDirectoryOpts {
+
     /// Permission granted to the created directory (e.g., 0777).
     /// Default: 0755.
     #[builder(setter(into, strip_option), default)]
@@ -1539,6 +1703,7 @@ pub struct DirectoryWithNewDirectoryOpts {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct DirectoryWithNewFileOpts {
+
     /// Permission given to the copied file (e.g., 0600).
     /// Default: 0644.
     #[builder(setter(into, strip_option), default)]
@@ -1547,11 +1712,14 @@ pub struct DirectoryWithNewFileOpts {
 
 impl Directory {
     /// Gets the difference between this directory and an another directory.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `other` - Identifier of the directory to compare.
-    pub fn diff(&self, other: DirectoryId) -> Directory {
+    pub fn diff(
+        &self,
+        other: DirectoryId,
+    ) -> Directory {
         let mut query = self.selection.select("diff");
 
         query = query.arg("other", other);
@@ -1560,14 +1728,17 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves a directory at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the directory to retrieve (e.g., "/src").
-    pub fn directory(&self, path: impl Into<String>) -> Directory {
+    pub fn directory(
+        &self,
+        path: impl Into<String>,
+    ) -> Directory {
         let mut query = self.selection.select("directory");
 
         query = query.arg("path", path.into());
@@ -1576,29 +1747,34 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Builds a new Docker container from this directory.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn docker_build(&self) -> Container {
-        let query = self.selection.select("dockerBuild");
+    pub fn docker_build(
+        &self,
+    ) -> Container {
+        let mut query = self.selection.select("dockerBuild");
 
         return Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Builds a new Docker container from this directory.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn docker_build_opts<'a>(&self, opts: DirectoryDockerBuildOpts<'a>) -> Container {
+    pub fn docker_build_opts<'a>(
+        &self,
+        opts: DirectoryDockerBuildOpts<'a>
+    ) -> Container {
         let mut query = self.selection.select("dockerBuild");
 
         if let Some(dockerfile) = opts.dockerfile {
@@ -1618,27 +1794,29 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Returns a list of files and directories at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub async fn entries(&self) -> eyre::Result<Vec<String>> {
-        let query = self.selection.select("entries");
+    pub async fn entries(
+        &self,
+    ) -> eyre::Result<Vec<String>> {
+        let mut query = self.selection.select("entries");
 
         query.execute(&graphql_client(&self.conn)).await
     }
 
     /// Returns a list of files and directories at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub async fn entries_opts<'a>(
         &self,
-        opts: DirectoryEntriesOpts<'a>,
+        opts: DirectoryEntriesOpts<'a>
     ) -> eyre::Result<Vec<String>> {
         let mut query = self.selection.select("entries");
 
@@ -1649,11 +1827,14 @@ impl Directory {
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Writes the contents of the directory to a path on the host.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the copied directory (e.g., "logs/").
-    pub async fn export(&self, path: impl Into<String>) -> eyre::Result<bool> {
+    pub async fn export(
+        &self,
+        path: impl Into<String>,
+    ) -> eyre::Result<bool> {
         let mut query = self.selection.select("export");
 
         query = query.arg("path", path.into());
@@ -1661,11 +1842,14 @@ impl Directory {
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves a file at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the file to retrieve (e.g., "README.md").
-    pub fn file(&self, path: impl Into<String>) -> File {
+    pub fn file(
+        &self,
+        path: impl Into<String>,
+    ) -> File {
         let mut query = self.selection.select("file");
 
         query = query.arg("path", path.into());
@@ -1674,16 +1858,21 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// The content-addressed identifier of the directory.
-    pub async fn id(&self) -> eyre::Result<DirectoryId> {
-        let query = self.selection.select("id");
+    pub async fn id(
+        &self,
+    ) -> eyre::Result<DirectoryId> {
+        let mut query = self.selection.select("id");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// load a project's metadata
-    pub fn load_project(&self, config_path: impl Into<String>) -> Project {
+    pub fn load_project(
+        &self,
+        config_path: impl Into<String>,
+    ) -> Project {
         let mut query = self.selection.select("loadProject");
 
         query = query.arg("configPath", config_path.into());
@@ -1692,15 +1881,18 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Creates a named sub-pipeline
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - Pipeline name.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn pipeline(&self, name: impl Into<String>) -> Directory {
+    pub fn pipeline(
+        &self,
+        name: impl Into<String>,
+    ) -> Directory {
         let mut query = self.selection.select("pipeline");
 
         query = query.arg("name", name.into());
@@ -1709,19 +1901,19 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Creates a named sub-pipeline
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - Pipeline name.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub fn pipeline_opts<'a>(
         &self,
         name: impl Into<String>,
-        opts: DirectoryPipelineOpts<'a>,
+        opts: DirectoryPipelineOpts<'a>
     ) -> Directory {
         let mut query = self.selection.select("pipeline");
 
@@ -1737,16 +1929,20 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this directory plus a directory written at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the written directory (e.g., "/src/").
     /// * `directory` - Identifier of the directory to copy.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_directory(&self, path: impl Into<String>, directory: DirectoryId) -> Directory {
+    pub fn with_directory(
+        &self,
+        path: impl Into<String>,
+        directory: DirectoryId,
+    ) -> Directory {
         let mut query = self.selection.select("withDirectory");
 
         query = query.arg("path", path.into());
@@ -1756,13 +1952,13 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves this directory plus a directory written at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the written directory (e.g., "/src/").
     /// * `directory` - Identifier of the directory to copy.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
@@ -1770,7 +1966,7 @@ impl Directory {
         &self,
         path: impl Into<String>,
         directory: DirectoryId,
-        opts: DirectoryWithDirectoryOpts<'a>,
+        opts: DirectoryWithDirectoryOpts<'a>
     ) -> Directory {
         let mut query = self.selection.select("withDirectory");
 
@@ -1787,16 +1983,20 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this directory plus the contents of the given file copied to the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the copied file (e.g., "/file.txt").
     /// * `source` - Identifier of the file to copy.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_file(&self, path: impl Into<String>, source: FileId) -> Directory {
+    pub fn with_file(
+        &self,
+        path: impl Into<String>,
+        source: FileId,
+    ) -> Directory {
         let mut query = self.selection.select("withFile");
 
         query = query.arg("path", path.into());
@@ -1806,13 +2006,13 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves this directory plus the contents of the given file copied to the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the copied file (e.g., "/file.txt").
     /// * `source` - Identifier of the file to copy.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
@@ -1820,7 +2020,7 @@ impl Directory {
         &self,
         path: impl Into<String>,
         source: FileId,
-        opts: DirectoryWithFileOpts,
+        opts: DirectoryWithFileOpts
     ) -> Directory {
         let mut query = self.selection.select("withFile");
 
@@ -1834,15 +2034,18 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this directory plus a new directory created at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the directory created (e.g., "/logs").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_new_directory(&self, path: impl Into<String>) -> Directory {
+    pub fn with_new_directory(
+        &self,
+        path: impl Into<String>,
+    ) -> Directory {
         let mut query = self.selection.select("withNewDirectory");
 
         query = query.arg("path", path.into());
@@ -1851,19 +2054,19 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves this directory plus a new directory created at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the directory created (e.g., "/logs").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub fn with_new_directory_opts(
         &self,
         path: impl Into<String>,
-        opts: DirectoryWithNewDirectoryOpts,
+        opts: DirectoryWithNewDirectoryOpts
     ) -> Directory {
         let mut query = self.selection.select("withNewDirectory");
 
@@ -1876,16 +2079,20 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this directory plus a new file written at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the written file (e.g., "/file.txt").
     /// * `contents` - Content of the written file (e.g., "Hello world!").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_new_file(&self, path: impl Into<String>, contents: impl Into<String>) -> Directory {
+    pub fn with_new_file(
+        &self,
+        path: impl Into<String>,
+        contents: impl Into<String>,
+    ) -> Directory {
         let mut query = self.selection.select("withNewFile");
 
         query = query.arg("path", path.into());
@@ -1895,13 +2102,13 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves this directory plus a new file written at the given path.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the written file (e.g., "/file.txt").
     /// * `contents` - Content of the written file (e.g., "Hello world!").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
@@ -1909,7 +2116,7 @@ impl Directory {
         &self,
         path: impl Into<String>,
         contents: impl Into<String>,
-        opts: DirectoryWithNewFileOpts,
+        opts: DirectoryWithNewFileOpts
     ) -> Directory {
         let mut query = self.selection.select("withNewFile");
 
@@ -1923,16 +2130,19 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this directory with all file/dir timestamps set to the given time.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `timestamp` - Timestamp to set dir/files in.
-    ///
+    /// 
     /// Formatted in seconds following Unix epoch (e.g., 1672531199).
-    pub fn with_timestamps(&self, timestamp: isize) -> Directory {
+    pub fn with_timestamps(
+        &self,
+        timestamp: isize,
+    ) -> Directory {
         let mut query = self.selection.select("withTimestamps");
 
         query = query.arg("timestamp", timestamp);
@@ -1941,14 +2151,17 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this directory with the directory at the given path removed.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the directory to remove (e.g., ".github/").
-    pub fn without_directory(&self, path: impl Into<String>) -> Directory {
+    pub fn without_directory(
+        &self,
+        path: impl Into<String>,
+    ) -> Directory {
         let mut query = self.selection.select("withoutDirectory");
 
         query = query.arg("path", path.into());
@@ -1957,14 +2170,17 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves this directory with the file at the given path removed.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the file to remove (e.g., "/file.txt").
-    pub fn without_file(&self, path: impl Into<String>) -> Directory {
+    pub fn without_file(
+        &self,
+        path: impl Into<String>,
+    ) -> Directory {
         let mut query = self.selection.select("withoutFile");
 
         query = query.arg("path", path.into());
@@ -1973,7 +2189,7 @@ impl Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 }
 #[derive(Debug, Clone)]
@@ -1985,14 +2201,18 @@ pub struct EnvVariable {
 
 impl EnvVariable {
     /// The environment variable name.
-    pub async fn name(&self) -> eyre::Result<String> {
-        let query = self.selection.select("name");
+    pub async fn name(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("name");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// The environment variable value.
-    pub async fn value(&self) -> eyre::Result<String> {
-        let query = self.selection.select("value");
+    pub async fn value(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("value");
 
         query.execute(&graphql_client(&self.conn)).await
     }
@@ -2006,17 +2226,22 @@ pub struct File {
 
 impl File {
     /// Retrieves the contents of the file.
-    pub async fn contents(&self) -> eyre::Result<String> {
-        let query = self.selection.select("contents");
+    pub async fn contents(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("contents");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Writes the file to a file path on the host.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the written directory (e.g., "output.txt").
-    pub async fn export(&self, path: impl Into<String>) -> eyre::Result<bool> {
+    pub async fn export(
+        &self,
+        path: impl Into<String>,
+    ) -> eyre::Result<bool> {
         let mut query = self.selection.select("export");
 
         query = query.arg("path", path.into());
@@ -2024,35 +2249,44 @@ impl File {
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves the content-addressed identifier of the file.
-    pub async fn id(&self) -> eyre::Result<FileId> {
-        let query = self.selection.select("id");
+    pub async fn id(
+        &self,
+    ) -> eyre::Result<FileId> {
+        let mut query = self.selection.select("id");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves a secret referencing the contents of this file.
-    pub fn secret(&self) -> Secret {
-        let query = self.selection.select("secret");
+    pub fn secret(
+        &self,
+    ) -> Secret {
+        let mut query = self.selection.select("secret");
 
         return Secret {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Gets the size of the file, in bytes.
-    pub async fn size(&self) -> eyre::Result<isize> {
-        let query = self.selection.select("size");
+    pub async fn size(
+        &self,
+    ) -> eyre::Result<isize> {
+        let mut query = self.selection.select("size");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Retrieves this file with its created/modified timestamps set to the given time.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `timestamp` - Timestamp to set dir/files in.
-    ///
+    /// 
     /// Formatted in seconds following Unix epoch (e.g., 1672531199).
-    pub fn with_timestamps(&self, timestamp: isize) -> File {
+    pub fn with_timestamps(
+        &self,
+        timestamp: isize,
+    ) -> File {
         let mut query = self.selection.select("withTimestamps");
 
         query = query.arg("timestamp", timestamp);
@@ -2061,7 +2295,7 @@ impl File {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 }
 #[derive(Debug, Clone)]
@@ -2073,6 +2307,7 @@ pub struct GitRef {
 
 #[derive(Builder, Debug, PartialEq)]
 pub struct GitRefTreeOpts<'a> {
+
     #[builder(setter(into, strip_option), default)]
     pub ssh_known_hosts: Option<&'a str>,
     #[builder(setter(into, strip_option), default)]
@@ -2081,32 +2316,39 @@ pub struct GitRefTreeOpts<'a> {
 
 impl GitRef {
     /// The digest of the current value of this ref.
-    pub async fn digest(&self) -> eyre::Result<String> {
-        let query = self.selection.select("digest");
+    pub async fn digest(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("digest");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// The filesystem tree at this ref.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn tree(&self) -> Directory {
-        let query = self.selection.select("tree");
+    pub fn tree(
+        &self,
+    ) -> Directory {
+        let mut query = self.selection.select("tree");
 
         return Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// The filesystem tree at this ref.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn tree_opts<'a>(&self, opts: GitRefTreeOpts<'a>) -> Directory {
+    pub fn tree_opts<'a>(
+        &self,
+        opts: GitRefTreeOpts<'a>
+    ) -> Directory {
         let mut query = self.selection.select("tree");
 
         if let Some(ssh_known_hosts) = opts.ssh_known_hosts {
@@ -2120,7 +2362,7 @@ impl GitRef {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 }
 #[derive(Debug, Clone)]
@@ -2132,11 +2374,14 @@ pub struct GitRepository {
 
 impl GitRepository {
     /// Returns details on one branch.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - Branch's name (e.g., "main").
-    pub fn branch(&self, name: impl Into<String>) -> GitRef {
+    pub fn branch(
+        &self,
+        name: impl Into<String>,
+    ) -> GitRef {
         let mut query = self.selection.select("branch");
 
         query = query.arg("name", name.into());
@@ -2145,20 +2390,25 @@ impl GitRepository {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Lists of branches on the repository.
-    pub async fn branches(&self) -> eyre::Result<Vec<String>> {
-        let query = self.selection.select("branches");
+    pub async fn branches(
+        &self,
+    ) -> eyre::Result<Vec<String>> {
+        let mut query = self.selection.select("branches");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Returns details on one commit.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `id` - Identifier of the commit (e.g., "b6315d8f2810962c601af73f86831f6866ea798b").
-    pub fn commit(&self, id: impl Into<String>) -> GitRef {
+    pub fn commit(
+        &self,
+        id: impl Into<String>,
+    ) -> GitRef {
         let mut query = self.selection.select("commit");
 
         query = query.arg("id", id.into());
@@ -2167,14 +2417,17 @@ impl GitRepository {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Returns details on one tag.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - Tag's name (e.g., "v0.3.9").
-    pub fn tag(&self, name: impl Into<String>) -> GitRef {
+    pub fn tag(
+        &self,
+        name: impl Into<String>,
+    ) -> GitRef {
         let mut query = self.selection.select("tag");
 
         query = query.arg("name", name.into());
@@ -2183,11 +2436,13 @@ impl GitRepository {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Lists of tags on the repository.
-    pub async fn tags(&self) -> eyre::Result<Vec<String>> {
-        let query = self.selection.select("tags");
+    pub async fn tags(
+        &self,
+    ) -> eyre::Result<Vec<String>> {
+        let mut query = self.selection.select("tags");
 
         query.execute(&graphql_client(&self.conn)).await
     }
@@ -2201,6 +2456,7 @@ pub struct Host {
 
 #[derive(Builder, Debug, PartialEq)]
 pub struct HostDirectoryOpts<'a> {
+
     /// Exclude artifacts that match the given pattern (e.g., ["node_modules/", ".git*"]).
     #[builder(setter(into, strip_option), default)]
     pub exclude: Option<Vec<&'a str>>,
@@ -2210,6 +2466,7 @@ pub struct HostDirectoryOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct HostWorkdirOpts<'a> {
+
     /// Exclude artifacts that match the given pattern (e.g., ["node_modules/", ".git*"]).
     #[builder(setter(into, strip_option), default)]
     pub exclude: Option<Vec<&'a str>>,
@@ -2220,12 +2477,15 @@ pub struct HostWorkdirOpts<'a> {
 
 impl Host {
     /// Accesses a directory on the host.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the directory to access (e.g., ".").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn directory(&self, path: impl Into<String>) -> Directory {
+    pub fn directory(
+        &self,
+        path: impl Into<String>,
+    ) -> Directory {
         let mut query = self.selection.select("directory");
 
         query = query.arg("path", path.into());
@@ -2234,19 +2494,19 @@ impl Host {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Accesses a directory on the host.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the directory to access (e.g., ".").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
     pub fn directory_opts<'a>(
         &self,
         path: impl Into<String>,
-        opts: HostDirectoryOpts<'a>,
+        opts: HostDirectoryOpts<'a>
     ) -> Directory {
         let mut query = self.selection.select("directory");
 
@@ -2262,14 +2522,17 @@ impl Host {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Accesses an environment variable on the host.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - Name of the environment variable (e.g., "PATH").
-    pub fn env_variable(&self, name: impl Into<String>) -> HostVariable {
+    pub fn env_variable(
+        &self,
+        name: impl Into<String>,
+    ) -> HostVariable {
         let mut query = self.selection.select("envVariable");
 
         query = query.arg("name", name.into());
@@ -2278,14 +2541,17 @@ impl Host {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Accesses a Unix socket on the host.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `path` - Location of the Unix socket (e.g., "/var/run/docker.sock").
-    pub fn unix_socket(&self, path: impl Into<String>) -> Socket {
+    pub fn unix_socket(
+        &self,
+        path: impl Into<String>,
+    ) -> Socket {
         let mut query = self.selection.select("unixSocket");
 
         query = query.arg("path", path.into());
@@ -2294,29 +2560,34 @@ impl Host {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Retrieves the current working directory on the host.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn workdir(&self) -> Directory {
-        let query = self.selection.select("workdir");
+    pub fn workdir(
+        &self,
+    ) -> Directory {
+        let mut query = self.selection.select("workdir");
 
         return Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Retrieves the current working directory on the host.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn workdir_opts<'a>(&self, opts: HostWorkdirOpts<'a>) -> Directory {
+    pub fn workdir_opts<'a>(
+        &self,
+        opts: HostWorkdirOpts<'a>
+    ) -> Directory {
         let mut query = self.selection.select("workdir");
 
         if let Some(exclude) = opts.exclude {
@@ -2330,7 +2601,7 @@ impl Host {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 }
 #[derive(Debug, Clone)]
@@ -2342,18 +2613,22 @@ pub struct HostVariable {
 
 impl HostVariable {
     /// A secret referencing the value of this variable.
-    pub fn secret(&self) -> Secret {
-        let query = self.selection.select("secret");
+    pub fn secret(
+        &self,
+    ) -> Secret {
+        let mut query = self.selection.select("secret");
 
         return Secret {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// The value of this variable.
-    pub async fn value(&self) -> eyre::Result<String> {
-        let query = self.selection.select("value");
+    pub async fn value(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("value");
 
         query.execute(&graphql_client(&self.conn)).await
     }
@@ -2367,14 +2642,18 @@ pub struct Label {
 
 impl Label {
     /// The label name.
-    pub async fn name(&self) -> eyre::Result<String> {
-        let query = self.selection.select("name");
+    pub async fn name(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("name");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// The label value.
-    pub async fn value(&self) -> eyre::Result<String> {
-        let query = self.selection.select("value");
+    pub async fn value(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("value");
 
         query.execute(&graphql_client(&self.conn)).await
     }
@@ -2388,20 +2667,26 @@ pub struct Port {
 
 impl Port {
     /// The port description.
-    pub async fn description(&self) -> eyre::Result<String> {
-        let query = self.selection.select("description");
+    pub async fn description(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("description");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// The port number.
-    pub async fn port(&self) -> eyre::Result<isize> {
-        let query = self.selection.select("port");
+    pub async fn port(
+        &self,
+    ) -> eyre::Result<isize> {
+        let mut query = self.selection.select("port");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// The transport layer network protocol.
-    pub async fn protocol(&self) -> eyre::Result<NetworkProtocol> {
-        let query = self.selection.select("protocol");
+    pub async fn protocol(
+        &self,
+    ) -> eyre::Result<NetworkProtocol> {
+        let mut query = self.selection.select("protocol");
 
         query.execute(&graphql_client(&self.conn)).await
     }
@@ -2415,46 +2700,58 @@ pub struct Project {
 
 impl Project {
     /// extensions in this project
-    pub fn extensions(&self) -> Vec<Project> {
-        let query = self.selection.select("extensions");
+    pub fn extensions(
+        &self,
+    ) -> Vec<Project> {
+        let mut query = self.selection.select("extensions");
 
         return vec![Project {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        }];
+        }]
     }
     /// Code files generated by the SDKs in the project
-    pub fn generated_code(&self) -> Directory {
-        let query = self.selection.select("generatedCode");
+    pub fn generated_code(
+        &self,
+    ) -> Directory {
+        let mut query = self.selection.select("generatedCode");
 
         return Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// install the project's schema
-    pub async fn install(&self) -> eyre::Result<bool> {
-        let query = self.selection.select("install");
+    pub async fn install(
+        &self,
+    ) -> eyre::Result<bool> {
+        let mut query = self.selection.select("install");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// name of the project
-    pub async fn name(&self) -> eyre::Result<String> {
-        let query = self.selection.select("name");
+    pub async fn name(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("name");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// schema provided by the project
-    pub async fn schema(&self) -> eyre::Result<String> {
-        let query = self.selection.select("schema");
+    pub async fn schema(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("schema");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// sdk used to generate code for and/or execute this project
-    pub async fn sdk(&self) -> eyre::Result<String> {
-        let query = self.selection.select("sdk");
+    pub async fn sdk(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("sdk");
 
         query.execute(&graphql_client(&self.conn)).await
     }
@@ -2468,6 +2765,7 @@ pub struct Query {
 
 #[derive(Builder, Debug, PartialEq)]
 pub struct QueryContainerOpts {
+
     #[builder(setter(into, strip_option), default)]
     pub id: Option<ContainerId>,
     #[builder(setter(into, strip_option), default)]
@@ -2475,11 +2773,13 @@ pub struct QueryContainerOpts {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct QueryDirectoryOpts {
+
     #[builder(setter(into, strip_option), default)]
     pub id: Option<DirectoryId>,
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct QueryGitOpts {
+
     /// Set to true to keep .git directory.
     #[builder(setter(into, strip_option), default)]
     pub keep_git_dir: Option<bool>,
@@ -2489,12 +2789,14 @@ pub struct QueryGitOpts {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct QueryHttpOpts {
+
     /// A service which must be started before the URL is fetched.
     #[builder(setter(into, strip_option), default)]
     pub experimental_service_host: Option<ContainerId>,
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct QueryPipelineOpts<'a> {
+
     /// Pipeline description.
     #[builder(setter(into, strip_option), default)]
     pub description: Option<&'a str>,
@@ -2504,17 +2806,21 @@ pub struct QueryPipelineOpts<'a> {
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct QuerySocketOpts {
+
     #[builder(setter(into, strip_option), default)]
     pub id: Option<SocketId>,
 }
 
 impl Query {
     /// Constructs a cache volume for a given cache key.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `key` - A string identifier to target this cache volume (e.g., "modules-cache").
-    pub fn cache_volume(&self, key: impl Into<String>) -> CacheVolume {
+    pub fn cache_volume(
+        &self,
+        key: impl Into<String>,
+    ) -> CacheVolume {
         let mut query = self.selection.select("cacheVolume");
 
         query = query.arg("key", key.into());
@@ -2523,35 +2829,40 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Loads a container from ID.
     /// Null ID returns an empty container (scratch).
     /// Optional platform argument initializes new containers to execute and publish as that platform.
     /// Platform defaults to that of the builder's host.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn container(&self) -> Container {
-        let query = self.selection.select("container");
+    pub fn container(
+        &self,
+    ) -> Container {
+        let mut query = self.selection.select("container");
 
         return Container {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Loads a container from ID.
     /// Null ID returns an empty container (scratch).
     /// Optional platform argument initializes new containers to execute and publish as that platform.
     /// Platform defaults to that of the builder's host.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn container_opts(&self, opts: QueryContainerOpts) -> Container {
+    pub fn container_opts(
+        &self,
+        opts: QueryContainerOpts
+    ) -> Container {
         let mut query = self.selection.select("container");
 
         if let Some(id) = opts.id {
@@ -2565,35 +2876,42 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// The default platform of the builder.
-    pub async fn default_platform(&self) -> eyre::Result<Platform> {
-        let query = self.selection.select("defaultPlatform");
+    pub async fn default_platform(
+        &self,
+    ) -> eyre::Result<Platform> {
+        let mut query = self.selection.select("defaultPlatform");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// Load a directory by ID. No argument produces an empty directory.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn directory(&self) -> Directory {
-        let query = self.selection.select("directory");
+    pub fn directory(
+        &self,
+    ) -> Directory {
+        let mut query = self.selection.select("directory");
 
         return Directory {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Load a directory by ID. No argument produces an empty directory.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn directory_opts(&self, opts: QueryDirectoryOpts) -> Directory {
+    pub fn directory_opts(
+        &self,
+        opts: QueryDirectoryOpts
+    ) -> Directory {
         let mut query = self.selection.select("directory");
 
         if let Some(id) = opts.id {
@@ -2604,10 +2922,13 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Loads a file by ID.
-    pub fn file(&self, id: FileId) -> File {
+    pub fn file(
+        &self,
+        id: FileId,
+    ) -> File {
         let mut query = self.selection.select("file");
 
         query = query.arg("id", id);
@@ -2616,17 +2937,20 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Queries a git repository.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `url` - Url of the git repository.
     /// Can be formatted as https://{host}/{owner}/{repo}, git@{host}/{owner}/{repo}
     /// Suffix ".git" is optional.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn git(&self, url: impl Into<String>) -> GitRepository {
+    pub fn git(
+        &self,
+        url: impl Into<String>,
+    ) -> GitRepository {
         let mut query = self.selection.select("git");
 
         query = query.arg("url", url.into());
@@ -2635,18 +2959,22 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Queries a git repository.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `url` - Url of the git repository.
     /// Can be formatted as https://{host}/{owner}/{repo}, git@{host}/{owner}/{repo}
     /// Suffix ".git" is optional.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn git_opts(&self, url: impl Into<String>, opts: QueryGitOpts) -> GitRepository {
+    pub fn git_opts(
+        &self,
+        url: impl Into<String>,
+        opts: QueryGitOpts
+    ) -> GitRepository {
         let mut query = self.selection.select("git");
 
         query = query.arg("url", url.into());
@@ -2661,25 +2989,30 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Queries the host environment.
-    pub fn host(&self) -> Host {
-        let query = self.selection.select("host");
+    pub fn host(
+        &self,
+    ) -> Host {
+        let mut query = self.selection.select("host");
 
         return Host {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Returns a file containing an http remote url content.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `url` - HTTP url to get the content from (e.g., "https://docs.dagger.io").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn http(&self, url: impl Into<String>) -> File {
+    pub fn http(
+        &self,
+        url: impl Into<String>,
+    ) -> File {
         let mut query = self.selection.select("http");
 
         query = query.arg("url", url.into());
@@ -2688,16 +3021,20 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Returns a file containing an http remote url content.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `url` - HTTP url to get the content from (e.g., "https://docs.dagger.io").
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn http_opts(&self, url: impl Into<String>, opts: QueryHttpOpts) -> File {
+    pub fn http_opts(
+        &self,
+        url: impl Into<String>,
+        opts: QueryHttpOpts
+    ) -> File {
         let mut query = self.selection.select("http");
 
         query = query.arg("url", url.into());
@@ -2709,15 +3046,18 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Creates a named sub-pipeline.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - Pipeline name.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn pipeline(&self, name: impl Into<String>) -> Query {
+    pub fn pipeline(
+        &self,
+        name: impl Into<String>,
+    ) -> Query {
         let mut query = self.selection.select("pipeline");
 
         query = query.arg("name", name.into());
@@ -2726,16 +3066,20 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Creates a named sub-pipeline.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `name` - Pipeline name.
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn pipeline_opts<'a>(&self, name: impl Into<String>, opts: QueryPipelineOpts<'a>) -> Query {
+    pub fn pipeline_opts<'a>(
+        &self,
+        name: impl Into<String>,
+        opts: QueryPipelineOpts<'a>
+    ) -> Query {
         let mut query = self.selection.select("pipeline");
 
         query = query.arg("name", name.into());
@@ -2750,10 +3094,13 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Look up a project by name
-    pub fn project(&self, name: impl Into<String>) -> Project {
+    pub fn project(
+        &self,
+        name: impl Into<String>,
+    ) -> Project {
         let mut query = self.selection.select("project");
 
         query = query.arg("name", name.into());
@@ -2762,10 +3109,13 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Loads a secret from its ID.
-    pub fn secret(&self, id: SecretId) -> Secret {
+    pub fn secret(
+        &self,
+        id: SecretId,
+    ) -> Secret {
         let mut query = self.selection.select("secret");
 
         query = query.arg("id", id);
@@ -2774,29 +3124,34 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
     /// Loads a socket by its ID.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn socket(&self) -> Socket {
-        let query = self.selection.select("socket");
+    pub fn socket(
+        &self,
+    ) -> Socket {
+        let mut query = self.selection.select("socket");
 
         return Socket {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 
     /// Loads a socket by its ID.
-    ///
+    /// 
     /// # Arguments
-    ///
+    /// 
     /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn socket_opts(&self, opts: QuerySocketOpts) -> Socket {
+    pub fn socket_opts(
+        &self,
+        opts: QuerySocketOpts
+    ) -> Socket {
         let mut query = self.selection.select("socket");
 
         if let Some(id) = opts.id {
@@ -2807,7 +3162,7 @@ impl Query {
             proc: self.proc.clone(),
             selection: query,
             conn: self.conn.clone(),
-        };
+        }
     }
 }
 #[derive(Debug, Clone)]
@@ -2819,14 +3174,18 @@ pub struct Secret {
 
 impl Secret {
     /// The identifier for this secret.
-    pub async fn id(&self) -> eyre::Result<SecretId> {
-        let query = self.selection.select("id");
+    pub async fn id(
+        &self,
+    ) -> eyre::Result<SecretId> {
+        let mut query = self.selection.select("id");
 
         query.execute(&graphql_client(&self.conn)).await
     }
     /// The value of this secret.
-    pub async fn plaintext(&self) -> eyre::Result<String> {
-        let query = self.selection.select("plaintext");
+    pub async fn plaintext(
+        &self,
+    ) -> eyre::Result<String> {
+        let mut query = self.selection.select("plaintext");
 
         query.execute(&graphql_client(&self.conn)).await
     }
@@ -2840,17 +3199,19 @@ pub struct Socket {
 
 impl Socket {
     /// The content-addressed identifier of the socket.
-    pub async fn id(&self) -> eyre::Result<SocketId> {
-        let query = self.selection.select("id");
+    pub async fn id(
+        &self,
+    ) -> eyre::Result<SocketId> {
+        let mut query = self.selection.select("id");
 
         query.execute(&graphql_client(&self.conn)).await
     }
 }
 #[derive(Serialize, Deserialize, Clone, PartialEq, Debug)]
 pub enum CacheSharingMode {
-    SHARED,
-    PRIVATE,
     LOCKED,
+    PRIVATE,
+    SHARED,
 }
 #[derive(Serialize, Deserialize, Clone, PartialEq, Debug)]
 pub enum NetworkProtocol {