dagger_gleam

// AUTO-GENERATED BY DAGGER_GLEAM - DO NOT EDIT

import dagger/types.{type Client, type Try} as types
import dagger/interpreter
import dagger/dsl/types as t
import gleam/dynamic/decode
import gleam/list
import gleam/option.{type Option, None, Some}

pub type ForTerminal
pub type ForSearch
pub type FilterFns {
  Filter
  WithDirectory
}
pub type ForExport
pub type ForExists
pub type ForEntries
pub type ForDockerBuild

pub opaque type Opts(tag_) {
  Opts(
    source_root_path: Option(String),
    dockerfile: Option(String),
    platform: Option(String),
    build_args: Option(List(t.BuildArg)),
    target: Option(String),
    secrets: Option(List(t.Secret)),
    no_init: Option(Bool),
    ssh: Option(t.Socket),
    path: Option(String),
    expected_type: Option(t.ExistsType),
    do_not_follow_symlinks: Option(Bool),
    wipe: Option(Bool),
    exclude: Option(List(String)),
    include: Option(List(String)),
    gitignore: Option(Bool),
    paths: Option(List(String)),
    globs: Option(List(String)),
    literal: Option(Bool),
    multiline: Option(Bool),
    dotall: Option(Bool),
    insensitive: Option(Bool),
    skip_ignored: Option(Bool),
    skip_hidden: Option(Bool),
    files_only: Option(Bool),
    limit: Option(Int),
    container: Option(t.Container),
    cmd: Option(List(String)),
    experimental_privileged_nesting: Option(Bool),
    insecure_root_capabilities: Option(Bool),
    owner: Option(String),
    permissions: Option(Int),
  )
}

fn defaults() -> Opts(a) {
  Opts(
    source_root_path: None,
    dockerfile: None,
    platform: None,
    build_args: None,
    target: None,
    secrets: None,
    no_init: None,
    ssh: None,
    path: None,
    expected_type: None,
    do_not_follow_symlinks: None,
    wipe: None,
    exclude: None,
    include: None,
    gitignore: None,
    paths: None,
    globs: None,
    literal: None,
    multiline: None,
    dotall: None,
    insensitive: None,
    skip_ignored: None,
    skip_hidden: None,
    files_only: None,
    limit: None,
    container: None,
    cmd: None,
    experimental_privileged_nesting: None,
    insecure_root_capabilities: None,
    owner: None,
    permissions: None,
  )
}

pub fn none(opts: Opts(a)) -> Opts(a) {
  opts
}

pub fn opt_source_root_path(opts: Opts(a), val: String) -> Opts(a) {
  Opts(..opts, source_root_path: Some(val))
}

pub fn opt_dockerfile(opts: Opts(ForDockerBuild), val: String) -> Opts(ForDockerBuild) {
  Opts(..opts, dockerfile: Some(val))
}

pub fn opt_platform(opts: Opts(ForDockerBuild), val: String) -> Opts(ForDockerBuild) {
  Opts(..opts, platform: Some(val))
}

pub fn opt_build_args(opts: Opts(ForDockerBuild), val: List(t.BuildArg)) -> Opts(ForDockerBuild) {
  Opts(..opts, build_args: Some(val))
}

pub fn opt_target(opts: Opts(ForDockerBuild), val: String) -> Opts(ForDockerBuild) {
  Opts(..opts, target: Some(val))
}

pub fn opt_secrets(opts: Opts(ForDockerBuild), val: List(t.Secret)) -> Opts(ForDockerBuild) {
  Opts(..opts, secrets: Some(val))
}

pub fn opt_no_init(opts: Opts(ForDockerBuild), val: Bool) -> Opts(ForDockerBuild) {
  Opts(..opts, no_init: Some(val))
}

pub fn opt_ssh(opts: Opts(ForDockerBuild), val: t.Socket) -> Opts(ForDockerBuild) {
  Opts(..opts, ssh: Some(val))
}

pub fn opt_path(opts: Opts(ForEntries), val: String) -> Opts(ForEntries) {
  Opts(..opts, path: Some(val))
}

pub fn opt_expected_type(opts: Opts(ForExists), val: t.ExistsType) -> Opts(ForExists) {
  Opts(..opts, expected_type: Some(val))
}

pub fn opt_do_not_follow_symlinks(opts: Opts(a), val: Bool) -> Opts(a) {
  Opts(..opts, do_not_follow_symlinks: Some(val))
}

pub fn opt_wipe(opts: Opts(ForExport), val: Bool) -> Opts(ForExport) {
  Opts(..opts, wipe: Some(val))
}

pub fn opt_exclude(opts: Opts(FilterFns), val: List(String)) -> Opts(FilterFns) {
  Opts(..opts, exclude: Some(val))
}

pub fn opt_include(opts: Opts(FilterFns), val: List(String)) -> Opts(FilterFns) {
  Opts(..opts, include: Some(val))
}

pub fn opt_gitignore(opts: Opts(FilterFns), val: Bool) -> Opts(FilterFns) {
  Opts(..opts, gitignore: Some(val))
}

pub fn opt_paths(opts: Opts(ForSearch), val: List(String)) -> Opts(ForSearch) {
  Opts(..opts, paths: Some(val))
}

pub fn opt_globs(opts: Opts(ForSearch), val: List(String)) -> Opts(ForSearch) {
  Opts(..opts, globs: Some(val))
}

pub fn opt_literal(opts: Opts(ForSearch), val: Bool) -> Opts(ForSearch) {
  Opts(..opts, literal: Some(val))
}

pub fn opt_multiline(opts: Opts(ForSearch), val: Bool) -> Opts(ForSearch) {
  Opts(..opts, multiline: Some(val))
}

pub fn opt_dotall(opts: Opts(ForSearch), val: Bool) -> Opts(ForSearch) {
  Opts(..opts, dotall: Some(val))
}

pub fn opt_insensitive(opts: Opts(ForSearch), val: Bool) -> Opts(ForSearch) {
  Opts(..opts, insensitive: Some(val))
}

pub fn opt_skip_ignored(opts: Opts(ForSearch), val: Bool) -> Opts(ForSearch) {
  Opts(..opts, skip_ignored: Some(val))
}

pub fn opt_skip_hidden(opts: Opts(ForSearch), val: Bool) -> Opts(ForSearch) {
  Opts(..opts, skip_hidden: Some(val))
}

pub fn opt_files_only(opts: Opts(ForSearch), val: Bool) -> Opts(ForSearch) {
  Opts(..opts, files_only: Some(val))
}

pub fn opt_limit(opts: Opts(ForSearch), val: Int) -> Opts(ForSearch) {
  Opts(..opts, limit: Some(val))
}

pub fn opt_container(opts: Opts(ForTerminal), val: t.Container) -> Opts(ForTerminal) {
  Opts(..opts, container: Some(val))
}

pub fn opt_cmd(opts: Opts(ForTerminal), val: List(String)) -> Opts(ForTerminal) {
  Opts(..opts, cmd: Some(val))
}

pub fn opt_experimental_privileged_nesting(opts: Opts(ForTerminal), val: Bool) -> Opts(ForTerminal) {
  Opts(..opts, experimental_privileged_nesting: Some(val))
}

pub fn opt_insecure_root_capabilities(opts: Opts(ForTerminal), val: Bool) -> Opts(ForTerminal) {
  Opts(..opts, insecure_root_capabilities: Some(val))
}

pub fn opt_owner(opts: Opts(a), val: String) -> Opts(a) {
  Opts(..opts, owner: Some(val))
}

pub fn opt_permissions(opts: Opts(a), val: Int) -> Opts(a) {
  Opts(..opts, permissions: Some(val))
}

pub fn directory() -> t.Directory {
  let field = types.Field(name: "directory", args: [], subfields: [])
  t.Directory(op: types.Pure([field]))
}

/// Converts this directory to a local git repository
pub fn as_git(parent: t.Directory) -> t.GitRepository {
  let field = types.Field(name: "asGit", args: [], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.GitRepository(op: new_op)
}

fn encode_as_module(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.source_root_path {
      Some(val) -> Ok(#("sourceRootPath", types.GString(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Load the directory as a Dagger module source
pub fn as_module(parent: t.Directory, with with_fn: fn(Opts(a)) -> Opts(a)) -> t.Module {
  let opts = with_fn(defaults())
  let field = types.Field(name: "asModule", args: encode_as_module(opts), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Module(op: new_op)
}

fn encode_as_module_source(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.source_root_path {
      Some(val) -> Ok(#("sourceRootPath", types.GString(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Load the directory as a Dagger module source
pub fn as_module_source(parent: t.Directory, with with_fn: fn(Opts(a)) -> Opts(a)) -> t.ModuleSource {
  let opts = with_fn(defaults())
  let field = types.Field(name: "asModuleSource", args: encode_as_module_source(opts), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.ModuleSource(op: new_op)
}

/// Return the difference between this directory and another directory, typically an older snapshot.
/// The difference is encoded as a changeset, which also tracks removed files, and can be applied to other directories.
pub fn changes(parent: t.Directory, from from: t.Directory) -> t.Changeset {
  let field = types.Field(name: "changes", args: [#("from", types.GDeferred(from.op))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Changeset(op: new_op)
}

/// Change the owner of the directory contents recursively.
pub fn chown(parent: t.Directory, path path: String, owner owner: String) -> t.Directory {
  let field = types.Field(name: "chown", args: [#("path", types.GString(path)), #("owner", types.GString(owner))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Return the difference between this directory and an another directory. The difference is encoded as a directory.
pub fn diff(parent: t.Directory, other other: t.Directory) -> t.Directory {
  let field = types.Field(name: "diff", args: [#("other", types.GDeferred(other.op))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Return the directory's digest. The format of the digest is not guaranteed to be stable between releases of Dagger. It is guaranteed to be stable between invocations of the same Dagger engine.
pub fn digest(parent: t.Directory, client client: Client, then handler: fn(Try(String)) -> a) -> a {
  let field = types.Field(name: "digest", args: [], subfields: [])
  let op = {
    use q <- types.bind(parent.op)
    let full_query = list.append(q, [field])
    types.Fetch(
      fields: full_query,
      decoder: decode.dynamic,
      next: fn(dyn) {
        let path = types.make_path(full_query)
        case decode.run(dyn, decode.at(path, decode.string)) {
          Ok(val) -> types.Pure(Ok(val))
          Error(_) -> types.Pure(Error(types.DecodingError("digest")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

fn encode_docker_build(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.dockerfile {
      Some(val) -> Ok(#("dockerfile", types.GString(val)))
      None -> Error(Nil)
    },
    case opts.platform {
      Some(val) -> Ok(#("platform", types.GString(val)))
      None -> Error(Nil)
    },
    case opts.build_args {
      Some(val) -> Ok(#("buildArgs", types.GList(list.map(val, fn(x) { types.GObject(t.build_arg_to_json(x)) }))))
      None -> Error(Nil)
    },
    case opts.target {
      Some(val) -> Ok(#("target", types.GString(val)))
      None -> Error(Nil)
    },
    case opts.secrets {
      Some(val) -> Ok(#("secrets", types.GList(list.map(val, fn(x) { types.GDeferred(x.op) }))))
      None -> Error(Nil)
    },
    case opts.no_init {
      Some(val) -> Ok(#("noInit", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.ssh {
      Some(val) -> Ok(#("ssh", types.GDeferred(val.op)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Use Dockerfile compatibility to build a container from this directory. Only use this function for Dockerfile compatibility. Otherwise use the native Container type directly, it is feature-complete and supports all Dockerfile features.
pub fn docker_build(parent: t.Directory, with with_fn: fn(Opts(ForDockerBuild)) -> Opts(ForDockerBuild)) -> t.Container {
  let opts = with_fn(defaults())
  let field = types.Field(name: "dockerBuild", args: encode_docker_build(opts), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Container(op: new_op)
}

fn encode_entries(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.path {
      Some(val) -> Ok(#("path", types.GString(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Returns a list of files and directories at the given path.
pub fn entries(parent: t.Directory, with with_fn: fn(Opts(ForEntries)) -> Opts(ForEntries), client client: Client, then handler: fn(Try(List(String))) -> a) -> a {
  let opts = with_fn(defaults())
  let field = types.Field(name: "entries", args: encode_entries(opts), subfields: [])
  let op = {
    use q <- types.bind(parent.op)
    let full_query = list.append(q, [field])
    types.Fetch(
      fields: full_query,
      decoder: decode.dynamic,
      next: fn(dyn) {
        let path = types.make_path(full_query)
        case decode.run(dyn, decode.at(path, decode.list(decode.string))) {
          Ok(val) -> types.Pure(Ok(val))
          Error(_) -> types.Pure(Error(types.DecodingError("entries")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

fn encode_exists(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.expected_type {
      Some(val) -> Ok(#("expectedType", types.GString(t.exists_type_to_json(val))))
      None -> Error(Nil)
    },
    case opts.do_not_follow_symlinks {
      Some(val) -> Ok(#("doNotFollowSymlinks", types.GBool(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// check if a file or directory exists
pub fn exists(parent: t.Directory, path path: String, with with_fn: fn(Opts(ForExists)) -> Opts(ForExists), client client: Client, then handler: fn(Try(Bool)) -> a) -> a {
  let opts = with_fn(defaults())
  let field = types.Field(name: "exists", args: list.append([#("path", types.GString(path))], encode_exists(opts)), subfields: [])
  let op = {
    use q <- types.bind(parent.op)
    let full_query = list.append(q, [field])
    types.Fetch(
      fields: full_query,
      decoder: decode.dynamic,
      next: fn(dyn) {
        let path = types.make_path(full_query)
        case decode.run(dyn, decode.at(path, decode.bool)) {
          Ok(val) -> types.Pure(Ok(val))
          Error(_) -> types.Pure(Error(types.DecodingError("exists")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

fn encode_export(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.wipe {
      Some(val) -> Ok(#("wipe", types.GBool(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Writes the contents of the directory to a path on the host.
pub fn export(parent: t.Directory, path path: String, with with_fn: fn(Opts(ForExport)) -> Opts(ForExport), client client: Client, then handler: fn(Try(String)) -> a) -> a {
  let opts = with_fn(defaults())
  let field = types.Field(name: "export", args: list.append([#("path", types.GString(path))], encode_export(opts)), subfields: [])
  let op = {
    use q <- types.bind(parent.op)
    let full_query = list.append(q, [field])
    types.Fetch(
      fields: full_query,
      decoder: decode.dynamic,
      next: fn(dyn) {
        let path = types.make_path(full_query)
        case decode.run(dyn, decode.at(path, decode.string)) {
          Ok(val) -> types.Pure(Ok(val))
          Error(_) -> types.Pure(Error(types.DecodingError("export")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

/// Retrieve a file at the given path.
pub fn file(parent: t.Directory, path path: String) -> t.File {
  let field = types.Field(name: "file", args: [#("path", types.GString(path))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.File(op: new_op)
}

fn encode_filter(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.exclude {
      Some(val) -> Ok(#("exclude", types.GList(list.map(val, fn(x) { types.GString(x) }))))
      None -> Error(Nil)
    },
    case opts.include {
      Some(val) -> Ok(#("include", types.GList(list.map(val, fn(x) { types.GString(x) }))))
      None -> Error(Nil)
    },
    case opts.gitignore {
      Some(val) -> Ok(#("gitignore", types.GBool(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Return a snapshot with some paths included or excluded
pub fn filter(parent: t.Directory, with with_fn: fn(Opts(FilterFns)) -> Opts(FilterFns)) -> t.Directory {
  let opts = with_fn(defaults())
  let field = types.Field(name: "filter", args: encode_filter(opts), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Search up the directory tree for a file or directory, and return its path. If no match, return null
pub fn find_up(parent: t.Directory, name name: String, start start: String, client client: Client, then handler: fn(Try(String)) -> a) -> a {
  let field = types.Field(name: "findUp", args: [#("name", types.GString(name)), #("start", types.GString(start))], subfields: [])
  let op = {
    use q <- types.bind(parent.op)
    let full_query = list.append(q, [field])
    types.Fetch(
      fields: full_query,
      decoder: decode.dynamic,
      next: fn(dyn) {
        let path = types.make_path(full_query)
        case decode.run(dyn, decode.at(path, decode.string)) {
          Ok(val) -> types.Pure(Ok(val))
          Error(_) -> types.Pure(Error(types.DecodingError("findUp")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

/// Returns a list of files and directories that matche the given pattern.
pub fn glob(parent: t.Directory, pattern pattern: String, client client: Client, then handler: fn(Try(List(String))) -> a) -> a {
  let field = types.Field(name: "glob", args: [#("pattern", types.GString(pattern))], subfields: [])
  let op = {
    use q <- types.bind(parent.op)
    let full_query = list.append(q, [field])
    types.Fetch(
      fields: full_query,
      decoder: decode.dynamic,
      next: fn(dyn) {
        let path = types.make_path(full_query)
        case decode.run(dyn, decode.at(path, decode.list(decode.string))) {
          Ok(val) -> types.Pure(Ok(val))
          Error(_) -> types.Pure(Error(types.DecodingError("glob")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

/// A unique identifier for this Directory.
pub fn id(parent: t.Directory) -> t.Directory {
  let field = types.Field(name: "id", args: [], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Returns the name of the directory.
pub fn name(parent: t.Directory, client client: Client, then handler: fn(Try(String)) -> a) -> a {
  let field = types.Field(name: "name", args: [], subfields: [])
  let op = {
    use q <- types.bind(parent.op)
    let full_query = list.append(q, [field])
    types.Fetch(
      fields: full_query,
      decoder: decode.dynamic,
      next: fn(dyn) {
        let path = types.make_path(full_query)
        case decode.run(dyn, decode.at(path, decode.string)) {
          Ok(val) -> types.Pure(Ok(val))
          Error(_) -> types.Pure(Error(types.DecodingError("name")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

fn encode_search(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.paths {
      Some(val) -> Ok(#("paths", types.GList(list.map(val, fn(x) { types.GString(x) }))))
      None -> Error(Nil)
    },
    case opts.globs {
      Some(val) -> Ok(#("globs", types.GList(list.map(val, fn(x) { types.GString(x) }))))
      None -> Error(Nil)
    },
    case opts.literal {
      Some(val) -> Ok(#("literal", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.multiline {
      Some(val) -> Ok(#("multiline", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.dotall {
      Some(val) -> Ok(#("dotall", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.insensitive {
      Some(val) -> Ok(#("insensitive", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.skip_ignored {
      Some(val) -> Ok(#("skipIgnored", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.skip_hidden {
      Some(val) -> Ok(#("skipHidden", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.files_only {
      Some(val) -> Ok(#("filesOnly", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.limit {
      Some(val) -> Ok(#("limit", types.GInt(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Searches for content matching the given regular expression or literal string.
/// Uses Rust regex syntax; escape literal ., [, ], {, }, | with backslashes.
pub fn search(parent: t.Directory, pattern pattern: String, with with_fn: fn(Opts(ForSearch)) -> Opts(ForSearch), select select: fn(t.SearchResult) -> List(types.Field), client client: Client, then handler: fn(Try(List(t.SearchResult))) -> a) -> a {
  let opts = with_fn(defaults())
  let subfields = select(t.SearchResult(op: types.Pure([])))
  let field = types.Field(name: "search", args: list.append([#("pattern", types.GString(pattern))], encode_search(opts)), subfields: subfields)
  let op = {
    use q <- types.bind(parent.op)
    let full_query = list.append(q, [field])
    types.Fetch(
      fields: full_query,
      decoder: decode.dynamic,
      next: fn(dyn) {
        let path = types.make_path(full_query)
        case decode.run(dyn, decode.at(path, decode.list(decode.dynamic))) {
          Ok(items) -> types.Pure(Ok(list.map(items, fn(_) { t.SearchResult(op: types.Pure(full_query)) })))
          Error(_) -> types.Pure(Error(types.DecodingError("search")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

fn encode_stat(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.do_not_follow_symlinks {
      Some(val) -> Ok(#("doNotFollowSymlinks", types.GBool(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Return file status
pub fn stat(parent: t.Directory, path path: String, with with_fn: fn(Opts(a)) -> Opts(a)) -> t.Stat {
  let opts = with_fn(defaults())
  let field = types.Field(name: "stat", args: list.append([#("path", types.GString(path))], encode_stat(opts)), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Stat(op: new_op)
}

/// Force evaluation in the engine.
pub fn sync(parent: t.Directory) -> t.Directory {
  let field = types.Field(name: "sync", args: [], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

fn encode_terminal(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.container {
      Some(val) -> Ok(#("container", types.GDeferred(val.op)))
      None -> Error(Nil)
    },
    case opts.cmd {
      Some(val) -> Ok(#("cmd", types.GList(list.map(val, fn(x) { types.GString(x) }))))
      None -> Error(Nil)
    },
    case opts.experimental_privileged_nesting {
      Some(val) -> Ok(#("experimentalPrivilegedNesting", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.insecure_root_capabilities {
      Some(val) -> Ok(#("insecureRootCapabilities", types.GBool(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Opens an interactive terminal in new container with this directory mounted inside.
pub fn terminal(parent: t.Directory, with with_fn: fn(Opts(ForTerminal)) -> Opts(ForTerminal)) -> t.Directory {
  let opts = with_fn(defaults())
  let field = types.Field(name: "terminal", args: encode_terminal(opts), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Return a directory with changes from another directory applied to it.
pub fn with_changes(parent: t.Directory, changes changes: t.Changeset) -> t.Directory {
  let field = types.Field(name: "withChanges", args: [#("changes", types.GDeferred(changes.op))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

fn encode_with_directory(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.exclude {
      Some(val) -> Ok(#("exclude", types.GList(list.map(val, fn(x) { types.GString(x) }))))
      None -> Error(Nil)
    },
    case opts.include {
      Some(val) -> Ok(#("include", types.GList(list.map(val, fn(x) { types.GString(x) }))))
      None -> Error(Nil)
    },
    case opts.gitignore {
      Some(val) -> Ok(#("gitignore", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.owner {
      Some(val) -> Ok(#("owner", types.GString(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Return a snapshot with a directory added
pub fn with_directory(parent: t.Directory, path path: String, source source: t.Directory, with with_fn: fn(Opts(FilterFns)) -> Opts(FilterFns)) -> t.Directory {
  let opts = with_fn(defaults())
  let field = types.Field(name: "withDirectory", args: list.append([#("path", types.GString(path)), #("source", types.GDeferred(source.op))], encode_with_directory(opts)), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Raise an error.
pub fn with_error(parent: t.Directory, err err: String) -> t.Directory {
  let field = types.Field(name: "withError", args: [#("err", types.GString(err))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

fn encode_with_file(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.owner {
      Some(val) -> Ok(#("owner", types.GString(val)))
      None -> Error(Nil)
    },
    case opts.permissions {
      Some(val) -> Ok(#("permissions", types.GInt(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Retrieves this directory plus the contents of the given file copied to the given path.
pub fn with_file(parent: t.Directory, path path: String, source source: t.File, with with_fn: fn(Opts(a)) -> Opts(a)) -> t.Directory {
  let opts = with_fn(defaults())
  let field = types.Field(name: "withFile", args: list.append([#("path", types.GString(path)), #("source", types.GDeferred(source.op))], encode_with_file(opts)), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

fn encode_with_files(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.permissions {
      Some(val) -> Ok(#("permissions", types.GInt(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Retrieves this directory plus the contents of the given files copied to the given path.
pub fn with_files(parent: t.Directory, path path: String, sources sources: List(t.File), with with_fn: fn(Opts(a)) -> Opts(a)) -> t.Directory {
  let opts = with_fn(defaults())
  let field = types.Field(name: "withFiles", args: list.append([#("path", types.GString(path)), #("sources", types.GList(list.map(sources, fn(x) { types.GDeferred(x.op) })))], encode_with_files(opts)), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

fn encode_with_new_directory(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.permissions {
      Some(val) -> Ok(#("permissions", types.GInt(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Retrieves this directory plus a new directory created at the given path.
pub fn with_new_directory(parent: t.Directory, path path: String, with with_fn: fn(Opts(a)) -> Opts(a)) -> t.Directory {
  let opts = with_fn(defaults())
  let field = types.Field(name: "withNewDirectory", args: list.append([#("path", types.GString(path))], encode_with_new_directory(opts)), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

fn encode_with_new_file(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.permissions {
      Some(val) -> Ok(#("permissions", types.GInt(val)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Return a snapshot with a new file added
pub fn with_new_file(parent: t.Directory, path path: String, contents contents: String, with with_fn: fn(Opts(a)) -> Opts(a)) -> t.Directory {
  let opts = with_fn(defaults())
  let field = types.Field(name: "withNewFile", args: list.append([#("path", types.GString(path)), #("contents", types.GString(contents))], encode_with_new_file(opts)), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Retrieves this directory with the given Git-compatible patch applied.
pub fn with_patch(parent: t.Directory, patch patch: String) -> t.Directory {
  let field = types.Field(name: "withPatch", args: [#("patch", types.GString(patch))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Retrieves this directory with the given Git-compatible patch file applied.
pub fn with_patch_file(parent: t.Directory, patch patch: t.File) -> t.Directory {
  let field = types.Field(name: "withPatchFile", args: [#("patch", types.GDeferred(patch.op))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Return a snapshot with a symlink
pub fn with_symlink(parent: t.Directory, target target: String, link_name link_name: String) -> t.Directory {
  let field = types.Field(name: "withSymlink", args: [#("target", types.GString(target)), #("linkName", types.GString(link_name))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Retrieves this directory with all file/dir timestamps set to the given time.
pub fn with_timestamps(parent: t.Directory, timestamp timestamp: Int) -> t.Directory {
  let field = types.Field(name: "withTimestamps", args: [#("timestamp", types.GInt(timestamp))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Return a snapshot with a subdirectory removed
pub fn without_directory(parent: t.Directory, path path: String) -> t.Directory {
  let field = types.Field(name: "withoutDirectory", args: [#("path", types.GString(path))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Return a snapshot with a file removed
pub fn without_file(parent: t.Directory, path path: String) -> t.Directory {
  let field = types.Field(name: "withoutFile", args: [#("path", types.GString(path))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}

/// Return a snapshot with files removed
pub fn without_files(parent: t.Directory, paths paths: List(String)) -> t.Directory {
  let field = types.Field(name: "withoutFiles", args: [#("paths", types.GList(list.map(paths, fn(x) { types.GString(x) })))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}