diff --git a/crates/dagger-codegen/src/functions.rs b/crates/dagger-codegen/src/functions.rs
index f395706..c68c97a 100644
--- a/crates/dagger-codegen/src/functions.rs
+++ b/crates/dagger-codegen/src/functions.rs
@@ -168,6 +168,15 @@ pub fn type_field_has_optional(field: &FullTypeFields) -> bool {
 }
 
 pub fn type_ref_is_scalar(type_ref: &TypeRef) -> bool {
+    let mut type_ref = type_ref.clone();
+    if type_ref
+        .kind
+        .pipe(|k| *k == __TypeKind::NON_NULL)
+        .unwrap_or(false)
+    {
+        type_ref = *type_ref.of_type.unwrap().clone();
+    }
+
     type_ref
         .kind
         .pipe(|k| *k == __TypeKind::SCALAR)
@@ -175,6 +184,15 @@ pub fn type_ref_is_scalar(type_ref: &TypeRef) -> bool {
 }
 
 pub fn type_ref_is_object(type_ref: &TypeRef) -> bool {
+    let mut type_ref = type_ref.clone();
+    if type_ref
+        .kind
+        .pipe(|k| *k == __TypeKind::NON_NULL)
+        .unwrap_or(false)
+    {
+        type_ref = *type_ref.of_type.unwrap().clone();
+    }
+
     type_ref
         .kind
         .pipe(|k| *k == __TypeKind::OBJECT)
@@ -182,6 +200,15 @@ pub fn type_ref_is_object(type_ref: &TypeRef) -> bool {
 }
 
 pub fn type_ref_is_list(type_ref: &TypeRef) -> bool {
+    let mut type_ref = type_ref.clone();
+    if type_ref
+        .kind
+        .pipe(|k| *k == __TypeKind::NON_NULL)
+        .unwrap_or(false)
+    {
+        type_ref = *type_ref.of_type.unwrap().clone();
+    }
+
     type_ref
         .kind
         .pipe(|k| *k == __TypeKind::LIST)
diff --git a/crates/dagger-codegen/src/rust/functions.rs b/crates/dagger-codegen/src/rust/functions.rs
index 1069bc8..a73ff58 100644
--- a/crates/dagger-codegen/src/rust/functions.rs
+++ b/crates/dagger-codegen/src/rust/functions.rs
@@ -2,9 +2,11 @@ use convert_case::{Case, Casing};
 use dagger_core::introspection::FullTypeFields;
 use genco::prelude::rust;
 use genco::quote;
+use genco::tokens::quoted;
 
 use crate::functions::{
-    input_values_has_optionals, type_field_has_optional, type_ref_is_optional, CommonFunctions,
+    type_field_has_optional, type_ref_is_list, type_ref_is_object, type_ref_is_optional,
+    type_ref_is_scalar, CommonFunctions,
 };
 use crate::utility::OptionExt;
 
@@ -41,11 +43,101 @@ pub fn format_function(funcs: &CommonFunctions, field: &FullTypeFields) -> Optio
         $(signature)(
             $(args)
         ) -> $(output_type) {
-            todo!()
+            let mut query = self.selection.select($(quoted(field.name.as_ref())));
+
+            $(render_required_args(funcs, field))
+            $(render_optional_args(funcs, field))
+
+            $(render_execution(funcs, field))
         }
     })
 }
 
+fn render_required_args(funcs: &CommonFunctions, field: &FullTypeFields) -> Option<rust::Tokens> {
+    if let Some(args) = field.args.as_ref() {
+        let args = args
+            .into_iter()
+            .map(|a| {
+                a.as_ref().and_then(|s| {
+                    if type_ref_is_optional(&s.input_value.type_) {
+                        return None;
+                    }
+
+                    let n = format_struct_name(&s.input_value.name);
+                    let name = &s.input_value.name;
+
+                    Some(quote! {
+                        query.arg($(quoted(name)), $(n));
+                    })
+                })
+            })
+            .flatten()
+            .collect::<Vec<_>>();
+        let required_args = quote! {
+            $(for arg in args join ($['\r']) => $arg)
+        };
+
+        Some(required_args)
+    } else {
+        None
+    }
+}
+
+fn render_optional_args(funcs: &CommonFunctions, field: &FullTypeFields) -> Option<rust::Tokens> {
+    if let Some(args) = field.args.as_ref() {
+        let args = args
+            .into_iter()
+            .map(|a| {
+                a.as_ref().and_then(|s| {
+                    if !type_ref_is_optional(&s.input_value.type_) {
+                        return None;
+                    }
+
+                    let n = format_struct_name(&s.input_value.name);
+                    let name = &s.input_value.name;
+
+                    Some(quote! {
+                        if let Some($(&n)) = opts.$(&n) {
+                            query.arg($(quoted(name)), $(&n));
+                        }
+                    })
+                })
+            })
+            .flatten()
+            .collect::<Vec<_>>();
+
+        if args.len() == 0 {
+            return None;
+        }
+
+        let required_args = quote! {
+            if let Some(opts) = opts {
+                $(for arg in args join ($['\r']) => $arg)
+            }
+        };
+
+        Some(required_args)
+    } else {
+        None
+    }
+}
+
+fn render_execution(funcs: &CommonFunctions, field: &FullTypeFields) -> rust::Tokens {
+    if let Some(true) = field.type_.pipe(|t| type_ref_is_object(&t.type_ref)) {
+        let output_type = funcs.format_output_type(&field.type_.as_ref().unwrap().type_ref);
+        return quote! {
+            return $(output_type) {
+                proc: self.proc.clone(),
+                selection: query
+            }
+        };
+    }
+
+    quote! {
+        selection.execute()
+    }
+}
+
 fn format_function_args(funcs: &CommonFunctions, field: &FullTypeFields) -> Option<rust::Tokens> {
     if let Some(args) = field.args.as_ref() {
         let args = args
diff --git a/crates/dagger-codegen/src/rust/templates/input_tmpl.rs b/crates/dagger-codegen/src/rust/templates/input_tmpl.rs
index f502e2f..6632981 100644
--- a/crates/dagger-codegen/src/rust/templates/input_tmpl.rs
+++ b/crates/dagger-codegen/src/rust/templates/input_tmpl.rs
@@ -6,7 +6,10 @@ use crate::functions::CommonFunctions;
 use crate::rust::functions::{format_name, format_struct_name};
 
 pub fn render_input(funcs: &CommonFunctions, t: &FullType) -> eyre::Result<rust::Tokens> {
+    let deserialize = rust::import("serde", "Deserialize");
+    let serialize = rust::import("serde", "Serialize");
     Ok(quote! {
+        #[derive($serialize, $deserialize)]
         pub struct $(format_name(t.name.as_ref().unwrap())) {
             $(render_input_fields(funcs, t.input_fields.as_ref().unwrap_or(&Vec::new())  ))
         }
diff --git a/crates/dagger-codegen/src/rust/templates/object_tmpl.rs b/crates/dagger-codegen/src/rust/templates/object_tmpl.rs
index 9b09f80..a393cdc 100644
--- a/crates/dagger-codegen/src/rust/templates/object_tmpl.rs
+++ b/crates/dagger-codegen/src/rust/templates/object_tmpl.rs
@@ -2,18 +2,21 @@ use dagger_core::introspection::{FullType, FullTypeFields, FullTypeFieldsArgs};
 use genco::prelude::rust;
 use genco::quote;
 
-use crate::functions::{
-    input_values_has_optionals, type_field_has_optional, type_ref_is_optional, CommonFunctions,
-};
+use crate::functions::{type_ref_is_optional, CommonFunctions};
 use crate::rust::functions::{
     field_options_struct_name, format_function, format_name, format_struct_name,
 };
 use crate::utility::OptionExt;
 
 pub fn render_object(funcs: &CommonFunctions, t: &FullType) -> eyre::Result<rust::Tokens> {
+    let selection = rust::import("crate::querybuilder", "Selection");
+    let child = rust::import("std::process", "Child");
+    let arc = rust::import("std::sync", "Arc");
+
     Ok(quote! {
         pub struct $(t.name.pipe(|s| format_name(s))) {
-
+            pub proc: $arc<$child>,
+            pub selection: $selection,
         }
 
         $(t.fields.pipe(|f| render_optional_args(funcs, f)))
diff --git a/crates/dagger-codegen/src/rust/templates/scalar_tmpl.rs b/crates/dagger-codegen/src/rust/templates/scalar_tmpl.rs
index 7e2f84b..a83c664 100644
--- a/crates/dagger-codegen/src/rust/templates/scalar_tmpl.rs
+++ b/crates/dagger-codegen/src/rust/templates/scalar_tmpl.rs
@@ -6,7 +6,11 @@ use crate::rust::functions::format_name;
 use crate::utility::OptionExt;
 
 pub fn render_scalar(t: &FullType) -> eyre::Result<rust::Tokens> {
+    let deserialize = rust::import("serde", "Deserialize");
+    let serialize = rust::import("serde", "Serialize");
+
     Ok(quote! {
+        #[derive($serialize, $deserialize)]
         pub struct $(t.name.pipe(|n|format_name(n)))(String);
     })
 }
diff --git a/crates/dagger-sdk/src/gen.rs b/crates/dagger-sdk/src/gen.rs
index fe0f8b7..c78af70 100644
--- a/crates/dagger-sdk/src/gen.rs
+++ b/crates/dagger-sdk/src/gen.rs
@@ -1,22 +1,43 @@
+use crate::querybuilder::Selection;
+use serde::{Deserialize, Serialize};
+use std::process::Child;
+use std::sync::Arc;
+
+#[derive(Serialize, Deserialize)]
 pub struct CacheId(String);
+#[derive(Serialize, Deserialize)]
 pub struct ContainerId(String);
+#[derive(Serialize, Deserialize)]
 pub struct DirectoryId(String);
+#[derive(Serialize, Deserialize)]
 pub struct FileId(String);
+#[derive(Serialize, Deserialize)]
 pub struct Platform(String);
+#[derive(Serialize, Deserialize)]
 pub struct SecretId(String);
+#[derive(Serialize, Deserialize)]
 pub struct SocketId(String);
+#[derive(Serialize, Deserialize)]
 pub struct BuildArg {
     pub name: String,
     pub value: String,
 }
-pub struct CacheVolume {}
+pub struct CacheVolume {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 impl CacheVolume {
     pub fn id(&self) -> CacheId {
-        todo!()
+        let mut query = self.selection.select("id");
+
+        selection.execute()
     }
 }
-pub struct Container {}
+pub struct Container {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 pub struct ContainerBuildOpts {
     pub dockerfile: Option<String>,
@@ -65,76 +86,222 @@ pub struct ContainerWithNewFileOpts {
 
 impl Container {
     pub fn build(&self, context: DirectoryId, opts: Option<ContainerBuildOpts>) -> Container {
-        todo!()
+        let mut query = self.selection.select("build");
+
+        query.arg("context", context);
+        if let Some(opts) = opts {
+            if let Some(dockerfile) = opts.dockerfile {
+                query.arg("dockerfile", dockerfile);
+            }
+            if let Some(build_args) = opts.build_args {
+                query.arg("buildArgs", build_args);
+            }
+            if let Some(target) = opts.target {
+                query.arg("target", target);
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn default_args(&self) -> Vec<String> {
-        todo!()
+        let mut query = self.selection.select("defaultArgs");
+
+        selection.execute()
     }
     pub fn directory(&self, path: String) -> Directory {
-        todo!()
+        let mut query = self.selection.select("directory");
+
+        query.arg("path", path);
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn entrypoint(&self) -> Vec<String> {
-        todo!()
+        let mut query = self.selection.select("entrypoint");
+
+        selection.execute()
     }
     pub fn env_variable(&self, name: String) -> String {
-        todo!()
+        let mut query = self.selection.select("envVariable");
+
+        query.arg("name", name);
+
+        selection.execute()
     }
     pub fn env_variables(&self) -> Vec<EnvVariable> {
-        todo!()
+        let mut query = self.selection.select("envVariables");
+
+        selection.execute()
     }
     pub fn exec(&self, opts: Option<ContainerExecOpts>) -> Container {
-        todo!()
+        let mut query = self.selection.select("exec");
+
+        if let Some(opts) = opts {
+            if let Some(args) = opts.args {
+                query.arg("args", args);
+            }
+            if let Some(stdin) = opts.stdin {
+                query.arg("stdin", stdin);
+            }
+            if let Some(redirect_stdout) = opts.redirect_stdout {
+                query.arg("redirectStdout", redirect_stdout);
+            }
+            if let Some(redirect_stderr) = opts.redirect_stderr {
+                query.arg("redirectStderr", redirect_stderr);
+            }
+            if let Some(experimental_privileged_nesting) = opts.experimental_privileged_nesting {
+                query.arg(
+                    "experimentalPrivilegedNesting",
+                    experimental_privileged_nesting,
+                );
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn exit_code(&self) -> isize {
-        todo!()
+        let mut query = self.selection.select("exitCode");
+
+        selection.execute()
     }
     pub fn export(&self, path: String, opts: Option<ContainerExportOpts>) -> bool {
-        todo!()
+        let mut query = self.selection.select("export");
+
+        query.arg("path", path);
+        if let Some(opts) = opts {
+            if let Some(platform_variants) = opts.platform_variants {
+                query.arg("platformVariants", platform_variants);
+            }
+        }
+
+        selection.execute()
     }
     pub fn file(&self, path: String) -> File {
-        todo!()
+        let mut query = self.selection.select("file");
+
+        query.arg("path", path);
+
+        return File {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn from(&self, address: String) -> Container {
-        todo!()
+        let mut query = self.selection.select("from");
+
+        query.arg("address", address);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn fs(&self) -> Directory {
-        todo!()
+        let mut query = self.selection.select("fs");
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn id(&self) -> ContainerId {
-        todo!()
+        let mut query = self.selection.select("id");
+
+        selection.execute()
     }
     pub fn label(&self, name: String) -> String {
-        todo!()
+        let mut query = self.selection.select("label");
+
+        query.arg("name", name);
+
+        selection.execute()
     }
     pub fn labels(&self) -> Vec<Label> {
-        todo!()
+        let mut query = self.selection.select("labels");
+
+        selection.execute()
     }
     pub fn mounts(&self) -> Vec<String> {
-        todo!()
+        let mut query = self.selection.select("mounts");
+
+        selection.execute()
     }
     pub fn pipeline(&self, name: String, opts: Option<ContainerPipelineOpts>) -> Container {
-        todo!()
+        let mut query = self.selection.select("pipeline");
+
+        query.arg("name", name);
+        if let Some(opts) = opts {
+            if let Some(description) = opts.description {
+                query.arg("description", description);
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn platform(&self) -> Platform {
-        todo!()
+        let mut query = self.selection.select("platform");
+
+        selection.execute()
     }
     pub fn publish(&self, address: String, opts: Option<ContainerPublishOpts>) -> String {
-        todo!()
+        let mut query = self.selection.select("publish");
+
+        query.arg("address", address);
+        if let Some(opts) = opts {
+            if let Some(platform_variants) = opts.platform_variants {
+                query.arg("platformVariants", platform_variants);
+            }
+        }
+
+        selection.execute()
     }
     pub fn rootfs(&self) -> Directory {
-        todo!()
+        let mut query = self.selection.select("rootfs");
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn stderr(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("stderr");
+
+        selection.execute()
     }
     pub fn stdout(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("stdout");
+
+        selection.execute()
     }
     pub fn user(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("user");
+
+        selection.execute()
     }
     pub fn with_default_args(&self, opts: Option<ContainerWithDefaultArgsOpts>) -> Container {
-        todo!()
+        let mut query = self.selection.select("withDefaultArgs");
+
+        if let Some(opts) = opts {
+            if let Some(args) = opts.args {
+                query.arg("args", args);
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_directory(
         &self,
@@ -142,19 +309,81 @@ impl Container {
         directory: DirectoryId,
         opts: Option<ContainerWithDirectoryOpts>,
     ) -> Container {
-        todo!()
+        let mut query = self.selection.select("withDirectory");
+
+        query.arg("path", path);
+        query.arg("directory", directory);
+        if let Some(opts) = opts {
+            if let Some(exclude) = opts.exclude {
+                query.arg("exclude", exclude);
+            }
+            if let Some(include) = opts.include {
+                query.arg("include", include);
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_entrypoint(&self, args: Vec<String>) -> Container {
-        todo!()
+        let mut query = self.selection.select("withEntrypoint");
+
+        query.arg("args", args);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_env_variable(&self, name: String, value: String) -> Container {
-        todo!()
+        let mut query = self.selection.select("withEnvVariable");
+
+        query.arg("name", name);
+        query.arg("value", value);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_exec(&self, args: Vec<String>, opts: Option<ContainerWithExecOpts>) -> Container {
-        todo!()
+        let mut query = self.selection.select("withExec");
+
+        query.arg("args", args);
+        if let Some(opts) = opts {
+            if let Some(stdin) = opts.stdin {
+                query.arg("stdin", stdin);
+            }
+            if let Some(redirect_stdout) = opts.redirect_stdout {
+                query.arg("redirectStdout", redirect_stdout);
+            }
+            if let Some(redirect_stderr) = opts.redirect_stderr {
+                query.arg("redirectStderr", redirect_stderr);
+            }
+            if let Some(experimental_privileged_nesting) = opts.experimental_privileged_nesting {
+                query.arg(
+                    "experimentalPrivilegedNesting",
+                    experimental_privileged_nesting,
+                );
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_fs(&self, id: DirectoryId) -> Container {
-        todo!()
+        let mut query = self.selection.select("withFS");
+
+        query.arg("id", id);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_file(
         &self,
@@ -162,10 +391,31 @@ impl Container {
         source: FileId,
         opts: Option<ContainerWithFileOpts>,
     ) -> Container {
-        todo!()
+        let mut query = self.selection.select("withFile");
+
+        query.arg("path", path);
+        query.arg("source", source);
+        if let Some(opts) = opts {
+            if let Some(permissions) = opts.permissions {
+                query.arg("permissions", permissions);
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_label(&self, name: String, value: String) -> Container {
-        todo!()
+        let mut query = self.selection.select("withLabel");
+
+        query.arg("name", name);
+        query.arg("value", value);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_mounted_cache(
         &self,
@@ -173,55 +423,184 @@ impl Container {
         cache: CacheId,
         opts: Option<ContainerWithMountedCacheOpts>,
     ) -> Container {
-        todo!()
+        let mut query = self.selection.select("withMountedCache");
+
+        query.arg("path", path);
+        query.arg("cache", cache);
+        if let Some(opts) = opts {
+            if let Some(source) = opts.source {
+                query.arg("source", source);
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_mounted_directory(&self, path: String, source: DirectoryId) -> Container {
-        todo!()
+        let mut query = self.selection.select("withMountedDirectory");
+
+        query.arg("path", path);
+        query.arg("source", source);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_mounted_file(&self, path: String, source: FileId) -> Container {
-        todo!()
+        let mut query = self.selection.select("withMountedFile");
+
+        query.arg("path", path);
+        query.arg("source", source);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_mounted_secret(&self, path: String, source: SecretId) -> Container {
-        todo!()
+        let mut query = self.selection.select("withMountedSecret");
+
+        query.arg("path", path);
+        query.arg("source", source);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_mounted_temp(&self, path: String) -> Container {
-        todo!()
+        let mut query = self.selection.select("withMountedTemp");
+
+        query.arg("path", path);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_new_file(&self, path: String, opts: Option<ContainerWithNewFileOpts>) -> Container {
-        todo!()
+        let mut query = self.selection.select("withNewFile");
+
+        query.arg("path", path);
+        if let Some(opts) = opts {
+            if let Some(contents) = opts.contents {
+                query.arg("contents", contents);
+            }
+            if let Some(permissions) = opts.permissions {
+                query.arg("permissions", permissions);
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_rootfs(&self, id: DirectoryId) -> Container {
-        todo!()
+        let mut query = self.selection.select("withRootfs");
+
+        query.arg("id", id);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_secret_variable(&self, name: String, secret: SecretId) -> Container {
-        todo!()
+        let mut query = self.selection.select("withSecretVariable");
+
+        query.arg("name", name);
+        query.arg("secret", secret);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_unix_socket(&self, path: String, source: SocketId) -> Container {
-        todo!()
+        let mut query = self.selection.select("withUnixSocket");
+
+        query.arg("path", path);
+        query.arg("source", source);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_user(&self, name: String) -> Container {
-        todo!()
+        let mut query = self.selection.select("withUser");
+
+        query.arg("name", name);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_workdir(&self, path: String) -> Container {
-        todo!()
+        let mut query = self.selection.select("withWorkdir");
+
+        query.arg("path", path);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn without_env_variable(&self, name: String) -> Container {
-        todo!()
+        let mut query = self.selection.select("withoutEnvVariable");
+
+        query.arg("name", name);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn without_label(&self, name: String) -> Container {
-        todo!()
+        let mut query = self.selection.select("withoutLabel");
+
+        query.arg("name", name);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn without_mount(&self, path: String) -> Container {
-        todo!()
+        let mut query = self.selection.select("withoutMount");
+
+        query.arg("path", path);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn without_unix_socket(&self, path: String) -> Container {
-        todo!()
+        let mut query = self.selection.select("withoutUnixSocket");
+
+        query.arg("path", path);
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn workdir(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("workdir");
+
+        selection.execute()
     }
 }
-pub struct Directory {}
+pub struct Directory {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 pub struct DirectoryDockerBuildOpts {
     pub dockerfile: Option<String>,
@@ -251,31 +630,105 @@ pub struct DirectoryWithNewFileOpts {
 
 impl Directory {
     pub fn diff(&self, other: DirectoryId) -> Directory {
-        todo!()
+        let mut query = self.selection.select("diff");
+
+        query.arg("other", other);
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn directory(&self, path: String) -> Directory {
-        todo!()
+        let mut query = self.selection.select("directory");
+
+        query.arg("path", path);
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn docker_build(&self, opts: Option<DirectoryDockerBuildOpts>) -> Container {
-        todo!()
+        let mut query = self.selection.select("dockerBuild");
+
+        if let Some(opts) = opts {
+            if let Some(dockerfile) = opts.dockerfile {
+                query.arg("dockerfile", dockerfile);
+            }
+            if let Some(platform) = opts.platform {
+                query.arg("platform", platform);
+            }
+            if let Some(build_args) = opts.build_args {
+                query.arg("buildArgs", build_args);
+            }
+            if let Some(target) = opts.target {
+                query.arg("target", target);
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn entries(&self, opts: Option<DirectoryEntriesOpts>) -> Vec<String> {
-        todo!()
+        let mut query = self.selection.select("entries");
+
+        if let Some(opts) = opts {
+            if let Some(path) = opts.path {
+                query.arg("path", path);
+            }
+        }
+
+        selection.execute()
     }
     pub fn export(&self, path: String) -> bool {
-        todo!()
+        let mut query = self.selection.select("export");
+
+        query.arg("path", path);
+
+        selection.execute()
     }
     pub fn file(&self, path: String) -> File {
-        todo!()
+        let mut query = self.selection.select("file");
+
+        query.arg("path", path);
+
+        return File {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn id(&self) -> DirectoryId {
-        todo!()
+        let mut query = self.selection.select("id");
+
+        selection.execute()
     }
     pub fn load_project(&self, config_path: String) -> Project {
-        todo!()
+        let mut query = self.selection.select("loadProject");
+
+        query.arg("configPath", config_path);
+
+        return Project {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn pipeline(&self, name: String, opts: Option<DirectoryPipelineOpts>) -> Directory {
-        todo!()
+        let mut query = self.selection.select("pipeline");
+
+        query.arg("name", name);
+        if let Some(opts) = opts {
+            if let Some(description) = opts.description {
+                query.arg("description", description);
+            }
+        }
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_directory(
         &self,
@@ -283,7 +736,23 @@ impl Directory {
         directory: DirectoryId,
         opts: Option<DirectoryWithDirectoryOpts>,
     ) -> Directory {
-        todo!()
+        let mut query = self.selection.select("withDirectory");
+
+        query.arg("path", path);
+        query.arg("directory", directory);
+        if let Some(opts) = opts {
+            if let Some(exclude) = opts.exclude {
+                query.arg("exclude", exclude);
+            }
+            if let Some(include) = opts.include {
+                query.arg("include", include);
+            }
+        }
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_file(
         &self,
@@ -291,14 +760,39 @@ impl Directory {
         source: FileId,
         opts: Option<DirectoryWithFileOpts>,
     ) -> Directory {
-        todo!()
+        let mut query = self.selection.select("withFile");
+
+        query.arg("path", path);
+        query.arg("source", source);
+        if let Some(opts) = opts {
+            if let Some(permissions) = opts.permissions {
+                query.arg("permissions", permissions);
+            }
+        }
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_new_directory(
         &self,
         path: String,
         opts: Option<DirectoryWithNewDirectoryOpts>,
     ) -> Directory {
-        todo!()
+        let mut query = self.selection.select("withNewDirectory");
+
+        query.arg("path", path);
+        if let Some(opts) = opts {
+            if let Some(permissions) = opts.permissions {
+                query.arg("permissions", permissions);
+            }
+        }
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_new_file(
         &self,
@@ -306,51 +800,120 @@ impl Directory {
         contents: String,
         opts: Option<DirectoryWithNewFileOpts>,
     ) -> Directory {
-        todo!()
+        let mut query = self.selection.select("withNewFile");
+
+        query.arg("path", path);
+        query.arg("contents", contents);
+        if let Some(opts) = opts {
+            if let Some(permissions) = opts.permissions {
+                query.arg("permissions", permissions);
+            }
+        }
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn with_timestamps(&self, timestamp: isize) -> Directory {
-        todo!()
+        let mut query = self.selection.select("withTimestamps");
+
+        query.arg("timestamp", timestamp);
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn without_directory(&self, path: String) -> Directory {
-        todo!()
+        let mut query = self.selection.select("withoutDirectory");
+
+        query.arg("path", path);
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn without_file(&self, path: String) -> Directory {
-        todo!()
+        let mut query = self.selection.select("withoutFile");
+
+        query.arg("path", path);
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
 }
-pub struct EnvVariable {}
+pub struct EnvVariable {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 impl EnvVariable {
     pub fn name(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("name");
+
+        selection.execute()
     }
     pub fn value(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("value");
+
+        selection.execute()
     }
 }
-pub struct File {}
+pub struct File {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 impl File {
     pub fn contents(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("contents");
+
+        selection.execute()
     }
     pub fn export(&self, path: String) -> bool {
-        todo!()
+        let mut query = self.selection.select("export");
+
+        query.arg("path", path);
+
+        selection.execute()
     }
     pub fn id(&self) -> FileId {
-        todo!()
+        let mut query = self.selection.select("id");
+
+        selection.execute()
     }
     pub fn secret(&self) -> Secret {
-        todo!()
+        let mut query = self.selection.select("secret");
+
+        return Secret {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn size(&self) -> isize {
-        todo!()
+        let mut query = self.selection.select("size");
+
+        selection.execute()
     }
     pub fn with_timestamps(&self, timestamp: isize) -> File {
-        todo!()
+        let mut query = self.selection.select("withTimestamps");
+
+        query.arg("timestamp", timestamp);
+
+        return File {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
 }
-pub struct GitRef {}
+pub struct GitRef {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 pub struct GitRefTreeOpts {
     pub ssh_known_hosts: Option<String>,
@@ -359,32 +922,79 @@ pub struct GitRefTreeOpts {
 
 impl GitRef {
     pub fn digest(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("digest");
+
+        selection.execute()
     }
     pub fn tree(&self, opts: Option<GitRefTreeOpts>) -> Directory {
-        todo!()
+        let mut query = self.selection.select("tree");
+
+        if let Some(opts) = opts {
+            if let Some(ssh_known_hosts) = opts.ssh_known_hosts {
+                query.arg("sshKnownHosts", ssh_known_hosts);
+            }
+            if let Some(ssh_auth_socket) = opts.ssh_auth_socket {
+                query.arg("sshAuthSocket", ssh_auth_socket);
+            }
+        }
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
 }
-pub struct GitRepository {}
+pub struct GitRepository {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 impl GitRepository {
     pub fn branch(&self, name: String) -> GitRef {
-        todo!()
+        let mut query = self.selection.select("branch");
+
+        query.arg("name", name);
+
+        return GitRef {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn branches(&self) -> Vec<String> {
-        todo!()
+        let mut query = self.selection.select("branches");
+
+        selection.execute()
     }
     pub fn commit(&self, id: String) -> GitRef {
-        todo!()
+        let mut query = self.selection.select("commit");
+
+        query.arg("id", id);
+
+        return GitRef {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn tag(&self, name: String) -> GitRef {
-        todo!()
+        let mut query = self.selection.select("tag");
+
+        query.arg("name", name);
+
+        return GitRef {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn tags(&self) -> Vec<String> {
-        todo!()
+        let mut query = self.selection.select("tags");
+
+        selection.execute()
     }
 }
-pub struct Host {}
+pub struct Host {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 pub struct HostDirectoryOpts {
     pub exclude: Option<Vec<String>>,
@@ -397,61 +1007,142 @@ pub struct HostWorkdirOpts {
 
 impl Host {
     pub fn directory(&self, path: String, opts: Option<HostDirectoryOpts>) -> Directory {
-        todo!()
+        let mut query = self.selection.select("directory");
+
+        query.arg("path", path);
+        if let Some(opts) = opts {
+            if let Some(exclude) = opts.exclude {
+                query.arg("exclude", exclude);
+            }
+            if let Some(include) = opts.include {
+                query.arg("include", include);
+            }
+        }
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn env_variable(&self, name: String) -> HostVariable {
-        todo!()
+        let mut query = self.selection.select("envVariable");
+
+        query.arg("name", name);
+
+        return HostVariable {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn unix_socket(&self, path: String) -> Socket {
-        todo!()
+        let mut query = self.selection.select("unixSocket");
+
+        query.arg("path", path);
+
+        return Socket {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn workdir(&self, opts: Option<HostWorkdirOpts>) -> Directory {
-        todo!()
+        let mut query = self.selection.select("workdir");
+
+        if let Some(opts) = opts {
+            if let Some(exclude) = opts.exclude {
+                query.arg("exclude", exclude);
+            }
+            if let Some(include) = opts.include {
+                query.arg("include", include);
+            }
+        }
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
 }
-pub struct HostVariable {}
+pub struct HostVariable {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 impl HostVariable {
     pub fn secret(&self) -> Secret {
-        todo!()
+        let mut query = self.selection.select("secret");
+
+        return Secret {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn value(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("value");
+
+        selection.execute()
     }
 }
-pub struct Label {}
+pub struct Label {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 impl Label {
     pub fn name(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("name");
+
+        selection.execute()
     }
     pub fn value(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("value");
+
+        selection.execute()
     }
 }
-pub struct Project {}
+pub struct Project {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 impl Project {
     pub fn extensions(&self) -> Vec<Project> {
-        todo!()
+        let mut query = self.selection.select("extensions");
+
+        selection.execute()
     }
     pub fn generated_code(&self) -> Directory {
-        todo!()
+        let mut query = self.selection.select("generatedCode");
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn install(&self) -> bool {
-        todo!()
+        let mut query = self.selection.select("install");
+
+        selection.execute()
     }
     pub fn name(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("name");
+
+        selection.execute()
     }
     pub fn schema(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("schema");
+
+        selection.execute()
     }
     pub fn sdk(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("sdk");
+
+        selection.execute()
     }
 }
-pub struct Query {}
+pub struct Query {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 pub struct QueryContainerOpts {
     pub id: Option<ContainerId>,
@@ -472,56 +1163,170 @@ pub struct QuerySocketOpts {
 
 impl Query {
     pub fn cache_volume(&self, key: String) -> CacheVolume {
-        todo!()
+        let mut query = self.selection.select("cacheVolume");
+
+        query.arg("key", key);
+
+        return CacheVolume {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn container(&self, opts: Option<QueryContainerOpts>) -> Container {
-        todo!()
+        let mut query = self.selection.select("container");
+
+        if let Some(opts) = opts {
+            if let Some(id) = opts.id {
+                query.arg("id", id);
+            }
+            if let Some(platform) = opts.platform {
+                query.arg("platform", platform);
+            }
+        }
+
+        return Container {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn default_platform(&self) -> Platform {
-        todo!()
+        let mut query = self.selection.select("defaultPlatform");
+
+        selection.execute()
     }
     pub fn directory(&self, opts: Option<QueryDirectoryOpts>) -> Directory {
-        todo!()
+        let mut query = self.selection.select("directory");
+
+        if let Some(opts) = opts {
+            if let Some(id) = opts.id {
+                query.arg("id", id);
+            }
+        }
+
+        return Directory {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn file(&self, id: FileId) -> File {
-        todo!()
+        let mut query = self.selection.select("file");
+
+        query.arg("id", id);
+
+        return File {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn git(&self, url: String, opts: Option<QueryGitOpts>) -> GitRepository {
-        todo!()
+        let mut query = self.selection.select("git");
+
+        query.arg("url", url);
+        if let Some(opts) = opts {
+            if let Some(keep_git_dir) = opts.keep_git_dir {
+                query.arg("keepGitDir", keep_git_dir);
+            }
+        }
+
+        return GitRepository {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn host(&self) -> Host {
-        todo!()
+        let mut query = self.selection.select("host");
+
+        return Host {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn http(&self, url: String) -> File {
-        todo!()
+        let mut query = self.selection.select("http");
+
+        query.arg("url", url);
+
+        return File {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn pipeline(&self, name: String, opts: Option<QueryPipelineOpts>) -> Query {
-        todo!()
+        let mut query = self.selection.select("pipeline");
+
+        query.arg("name", name);
+        if let Some(opts) = opts {
+            if let Some(description) = opts.description {
+                query.arg("description", description);
+            }
+        }
+
+        return Query {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn project(&self, name: String) -> Project {
-        todo!()
+        let mut query = self.selection.select("project");
+
+        query.arg("name", name);
+
+        return Project {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn secret(&self, id: SecretId) -> Secret {
-        todo!()
+        let mut query = self.selection.select("secret");
+
+        query.arg("id", id);
+
+        return Secret {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
     pub fn socket(&self, opts: Option<QuerySocketOpts>) -> Socket {
-        todo!()
+        let mut query = self.selection.select("socket");
+
+        if let Some(opts) = opts {
+            if let Some(id) = opts.id {
+                query.arg("id", id);
+            }
+        }
+
+        return Socket {
+            proc: self.proc.clone(),
+            selection: query,
+        };
     }
 }
-pub struct Secret {}
+pub struct Secret {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 impl Secret {
     pub fn id(&self) -> SecretId {
-        todo!()
+        let mut query = self.selection.select("id");
+
+        selection.execute()
     }
     pub fn plaintext(&self) -> String {
-        todo!()
+        let mut query = self.selection.select("plaintext");
+
+        selection.execute()
     }
 }
-pub struct Socket {}
+pub struct Socket {
+    pub proc: Arc<Child>,
+    pub selection: Selection,
+}
 
 impl Socket {
     pub fn id(&self) -> SocketId {
-        todo!()
+        let mut query = self.selection.select("id");
+
+        selection.execute()
     }
 }