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 ForSecret
pub type ForModuleSource
pub type ForLlm
pub type ForHttp
pub type ForGit
pub type ForEnv
pub type ForCurrentWorkspace
pub type ForContainer

pub opaque type Opts(tag_) {
  Opts(
    platform: Option(String),
    skip_migration_check: Option(Bool),
    privileged: Option(Bool),
    writable: Option(Bool),
    permissions: Option(Int),
    ssh_known_hosts: Option(String),
    ssh_auth_socket: Option(t.Socket),
    http_auth_username: Option(String),
    http_auth_token: Option(t.Secret),
    http_auth_header: Option(t.Secret),
    experimental_service_host: Option(t.Service),
    name: Option(String),
    auth_header: Option(t.Secret),
    model: Option(String),
    max_a_p_i_calls: Option(Int),
    ref_pin: Option(String),
    disable_find_up: Option(Bool),
    allow_not_exists: Option(Bool),
    require_kind: Option(t.ModuleSourceKind),
    cache_key: Option(String),
  )
}

fn defaults() -> Opts(a) {
  Opts(
    platform: None,
    skip_migration_check: None,
    privileged: None,
    writable: None,
    permissions: None,
    ssh_known_hosts: None,
    ssh_auth_socket: None,
    http_auth_username: None,
    http_auth_token: None,
    http_auth_header: None,
    experimental_service_host: None,
    name: None,
    auth_header: None,
    model: None,
    max_a_p_i_calls: None,
    ref_pin: None,
    disable_find_up: None,
    allow_not_exists: None,
    require_kind: None,
    cache_key: None,
  )
}

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

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

pub fn opt_skip_migration_check(opts: Opts(ForCurrentWorkspace), val: Bool) -> Opts(ForCurrentWorkspace) {
  Opts(..opts, skip_migration_check: Some(val))
}

pub fn opt_privileged(opts: Opts(ForEnv), val: Bool) -> Opts(ForEnv) {
  Opts(..opts, privileged: Some(val))
}

pub fn opt_writable(opts: Opts(ForEnv), val: Bool) -> Opts(ForEnv) {
  Opts(..opts, writable: Some(val))
}

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

pub fn opt_ssh_known_hosts(opts: Opts(ForGit), val: String) -> Opts(ForGit) {
  Opts(..opts, ssh_known_hosts: Some(val))
}

pub fn opt_ssh_auth_socket(opts: Opts(ForGit), val: t.Socket) -> Opts(ForGit) {
  Opts(..opts, ssh_auth_socket: Some(val))
}

pub fn opt_http_auth_username(opts: Opts(ForGit), val: String) -> Opts(ForGit) {
  Opts(..opts, http_auth_username: Some(val))
}

pub fn opt_http_auth_token(opts: Opts(ForGit), val: t.Secret) -> Opts(ForGit) {
  Opts(..opts, http_auth_token: Some(val))
}

pub fn opt_http_auth_header(opts: Opts(ForGit), val: t.Secret) -> Opts(ForGit) {
  Opts(..opts, http_auth_header: Some(val))
}

pub fn opt_experimental_service_host(opts: Opts(a), val: t.Service) -> Opts(a) {
  Opts(..opts, experimental_service_host: Some(val))
}

pub fn opt_name(opts: Opts(ForHttp), val: String) -> Opts(ForHttp) {
  Opts(..opts, name: Some(val))
}

pub fn opt_auth_header(opts: Opts(ForHttp), val: t.Secret) -> Opts(ForHttp) {
  Opts(..opts, auth_header: Some(val))
}

pub fn opt_model(opts: Opts(ForLlm), val: String) -> Opts(ForLlm) {
  Opts(..opts, model: Some(val))
}

pub fn opt_max_a_p_i_calls(opts: Opts(ForLlm), val: Int) -> Opts(ForLlm) {
  Opts(..opts, max_a_p_i_calls: Some(val))
}

pub fn opt_ref_pin(opts: Opts(ForModuleSource), val: String) -> Opts(ForModuleSource) {
  Opts(..opts, ref_pin: Some(val))
}

pub fn opt_disable_find_up(opts: Opts(ForModuleSource), val: Bool) -> Opts(ForModuleSource) {
  Opts(..opts, disable_find_up: Some(val))
}

pub fn opt_allow_not_exists(opts: Opts(ForModuleSource), val: Bool) -> Opts(ForModuleSource) {
  Opts(..opts, allow_not_exists: Some(val))
}

pub fn opt_require_kind(opts: Opts(ForModuleSource), val: t.ModuleSourceKind) -> Opts(ForModuleSource) {
  Opts(..opts, require_kind: Some(val))
}

pub fn opt_cache_key(opts: Opts(ForSecret), val: String) -> Opts(ForSecret) {
  Opts(..opts, cache_key: Some(val))
}

/// initialize an address to load directories, containers, secrets or other object types.
pub fn address(value value: String) -> t.Address {
  let field = types.Field(name: "address", args: [#("value", types.GString(value))], subfields: [])
  t.Address(op: types.Pure([field]))
}

/// Constructs a cache volume for a given cache key.
pub fn cache_volume(key key: String) -> t.CacheVolume {
  let field = types.Field(name: "cacheVolume", args: [#("key", types.GString(key))], subfields: [])
  t.CacheVolume(op: types.Pure([field]))
}

/// Dagger Cloud configuration and state
pub fn cloud() -> t.Cloud {
  let field = types.Field(name: "cloud", args: [], subfields: [])
  t.Cloud(op: types.Pure([field]))
}

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

/// Creates a scratch container, with no image or metadata.
/// To pull an image, follow up with the "from" function.
pub fn container(with with_fn: fn(Opts(ForContainer)) -> Opts(ForContainer)) -> t.Container {
  let opts = with_fn(defaults())
  let field = types.Field(name: "container", args: encode_container(opts), subfields: [])
  t.Container(op: types.Pure([field]))
}

/// Returns the current environment
/// When called from a function invoked via an LLM tool call, this will be the LLM's current environment, including any modifications made through calling tools. Env values returned by functions become the new environment for subsequent calls, and Changeset values returned by functions are applied to the environment's workspace.
/// When called from a module function outside of an LLM, this returns an Env with the current module installed, and with the current module's source directory as its workspace.
pub fn current_env() -> t.Env {
  let field = types.Field(name: "currentEnv", args: [], subfields: [])
  t.Env(op: types.Pure([field]))
}

/// The FunctionCall context that the SDK caller is currently executing in.
/// If the caller is not currently executing in a function, this will return an error.
pub fn current_function_call() -> t.FunctionCall {
  let field = types.Field(name: "currentFunctionCall", args: [], subfields: [])
  t.FunctionCall(op: types.Pure([field]))
}

/// The module currently being served in the session, if any.
pub fn current_module() -> t.CurrentModule {
  let field = types.Field(name: "currentModule", args: [], subfields: [])
  t.CurrentModule(op: types.Pure([field]))
}

/// The TypeDef representations of the objects currently being served in the session.
pub fn current_type_defs(select select: fn(t.TypeDef) -> List(types.Field), client client: Client, then handler: fn(Try(List(t.TypeDef))) -> a) -> a {
  let subfields = select(t.TypeDef(op: types.Pure([])))
  let field = types.Field(name: "currentTypeDefs", args: [], subfields: subfields)
  let op = {
    use q <- types.bind(types.Pure([]))
    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.TypeDef(op: types.Pure(full_query)) })))
          Error(_) -> types.Pure(Error(types.DecodingError("currentTypeDefs")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

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

/// Detect and return the current workspace.
pub fn current_workspace(with with_fn: fn(Opts(ForCurrentWorkspace)) -> Opts(ForCurrentWorkspace)) -> t.Workspace {
  let opts = with_fn(defaults())
  let field = types.Field(name: "currentWorkspace", args: encode_current_workspace(opts), subfields: [])
  t.Workspace(op: types.Pure([field]))
}

/// The default platform of the engine.
pub fn default_platform(client client: Client, then handler: fn(Try(String)) -> a) -> a {
  let field = types.Field(name: "defaultPlatform", args: [], subfields: [])
  let op = {
    use q <- types.bind(types.Pure([]))
    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("defaultPlatform")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

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

/// The Dagger engine container configuration and state
pub fn engine() -> t.Engine {
  let field = types.Field(name: "engine", args: [], subfields: [])
  t.Engine(op: types.Pure([field]))
}

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

/// Initializes a new environment
pub fn env(with with_fn: fn(Opts(ForEnv)) -> Opts(ForEnv)) -> t.Env {
  let opts = with_fn(defaults())
  let field = types.Field(name: "env", args: encode_env(opts), subfields: [])
  t.Env(op: types.Pure([field]))
}

/// Initialize an environment file
pub fn env_file() -> t.EnvFile {
  let field = types.Field(name: "envFile", args: [], subfields: [])
  t.EnvFile(op: types.Pure([field]))
}

/// Create a new error.
pub fn error(message message: String) -> t.Error {
  let field = types.Field(name: "error", args: [#("message", types.GString(message))], subfields: [])
  t.Error(op: types.Pure([field]))
}

fn encode_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 })
}

/// Creates a file with the specified contents.
pub fn file(name name: String, contents contents: String, with with_fn: fn(Opts(a)) -> Opts(a)) -> t.File {
  let opts = with_fn(defaults())
  let field = types.Field(name: "file", args: list.append([#("name", types.GString(name)), #("contents", types.GString(contents))], encode_file(opts)), subfields: [])
  t.File(op: types.Pure([field]))
}

/// Creates a function.
pub fn function(name name: String, return_type return_type: t.TypeDef) -> t.Function {
  let field = types.Field(name: "function", args: [#("name", types.GString(name)), #("returnType", types.GDeferred(return_type.op))], subfields: [])
  t.Function(op: types.Pure([field]))
}

/// Create a code generation result, given a directory containing the generated code.
pub fn generated_code(code code: t.Directory) -> t.GeneratedCode {
  let field = types.Field(name: "generatedCode", args: [#("code", types.GDeferred(code.op))], subfields: [])
  t.GeneratedCode(op: types.Pure([field]))
}

fn encode_git(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.ssh_known_hosts {
      Some(val) -> Ok(#("sshKnownHosts", types.GString(val)))
      None -> Error(Nil)
    },
    case opts.ssh_auth_socket {
      Some(val) -> Ok(#("sshAuthSocket", types.GDeferred(val.op)))
      None -> Error(Nil)
    },
    case opts.http_auth_username {
      Some(val) -> Ok(#("httpAuthUsername", types.GString(val)))
      None -> Error(Nil)
    },
    case opts.http_auth_token {
      Some(val) -> Ok(#("httpAuthToken", types.GDeferred(val.op)))
      None -> Error(Nil)
    },
    case opts.http_auth_header {
      Some(val) -> Ok(#("httpAuthHeader", types.GDeferred(val.op)))
      None -> Error(Nil)
    },
    case opts.experimental_service_host {
      Some(val) -> Ok(#("experimentalServiceHost", types.GDeferred(val.op)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Queries a Git repository.
pub fn git(url url: String, with with_fn: fn(Opts(ForGit)) -> Opts(ForGit)) -> t.GitRepository {
  let opts = with_fn(defaults())
  let field = types.Field(name: "git", args: list.append([#("url", types.GString(url))], encode_git(opts)), subfields: [])
  t.GitRepository(op: types.Pure([field]))
}

/// Queries the host environment.
pub fn host() -> t.Host {
  let field = types.Field(name: "host", args: [], subfields: [])
  t.Host(op: types.Pure([field]))
}

fn encode_http(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.permissions {
      Some(val) -> Ok(#("permissions", types.GInt(val)))
      None -> Error(Nil)
    },
    case opts.experimental_service_host {
      Some(val) -> Ok(#("experimentalServiceHost", types.GDeferred(val.op)))
      None -> Error(Nil)
    },
    case opts.name {
      Some(val) -> Ok(#("name", types.GString(val)))
      None -> Error(Nil)
    },
    case opts.auth_header {
      Some(val) -> Ok(#("authHeader", types.GDeferred(val.op)))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Returns a file containing an http remote url content.
pub fn http(url url: String, with with_fn: fn(Opts(ForHttp)) -> Opts(ForHttp)) -> t.File {
  let opts = with_fn(defaults())
  let field = types.Field(name: "http", args: list.append([#("url", types.GString(url))], encode_http(opts)), subfields: [])
  t.File(op: types.Pure([field]))
}

/// Initialize a JSON value
pub fn json() -> t.JSONValue {
  let field = types.Field(name: "json", args: [], subfields: [])
  t.JSONValue(op: types.Pure([field]))
}

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

/// Initialize a Large Language Model (LLM)
pub fn llm(with with_fn: fn(Opts(ForLlm)) -> Opts(ForLlm)) -> t.LLM {
  let opts = with_fn(defaults())
  let field = types.Field(name: "llm", args: encode_llm(opts), subfields: [])
  t.LLM(op: types.Pure([field]))
}

/// Load a Address from its ID.
pub fn load_address_from_i_d(id id: t.Address) -> t.Address {
  let field = types.Field(name: "loadAddressFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Address(op: types.Pure([field]))
}

/// Load a Binding from its ID.
pub fn load_binding_from_i_d(id id: t.Binding) -> t.Binding {
  let field = types.Field(name: "loadBindingFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Binding(op: types.Pure([field]))
}

/// Load a CacheVolume from its ID.
pub fn load_cache_volume_from_i_d(id id: t.CacheVolume) -> t.CacheVolume {
  let field = types.Field(name: "loadCacheVolumeFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.CacheVolume(op: types.Pure([field]))
}

/// Load a Changeset from its ID.
pub fn load_changeset_from_i_d(id id: t.Changeset) -> t.Changeset {
  let field = types.Field(name: "loadChangesetFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Changeset(op: types.Pure([field]))
}

/// Load a Check from its ID.
pub fn load_check_from_i_d(id id: t.Check) -> t.Check {
  let field = types.Field(name: "loadCheckFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Check(op: types.Pure([field]))
}

/// Load a CheckGroup from its ID.
pub fn load_check_group_from_i_d(id id: t.CheckGroup) -> t.CheckGroup {
  let field = types.Field(name: "loadCheckGroupFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.CheckGroup(op: types.Pure([field]))
}

/// Load a Cloud from its ID.
pub fn load_cloud_from_i_d(id id: t.Cloud) -> t.Cloud {
  let field = types.Field(name: "loadCloudFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Cloud(op: types.Pure([field]))
}

/// Load a Container from its ID.
pub fn load_container_from_i_d(id id: t.Container) -> t.Container {
  let field = types.Field(name: "loadContainerFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Container(op: types.Pure([field]))
}

/// Load a CurrentModule from its ID.
pub fn load_current_module_from_i_d(id id: t.CurrentModule) -> t.CurrentModule {
  let field = types.Field(name: "loadCurrentModuleFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.CurrentModule(op: types.Pure([field]))
}

/// Load a Directory from its ID.
pub fn load_directory_from_i_d(id id: t.Directory) -> t.Directory {
  let field = types.Field(name: "loadDirectoryFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Directory(op: types.Pure([field]))
}

/// Load a EngineCacheEntry from its ID.
pub fn load_engine_cache_entry_from_i_d(id id: t.EngineCacheEntry) -> t.EngineCacheEntry {
  let field = types.Field(name: "loadEngineCacheEntryFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.EngineCacheEntry(op: types.Pure([field]))
}

/// Load a EngineCacheEntrySet from its ID.
pub fn load_engine_cache_entry_set_from_i_d(id id: t.EngineCacheEntrySet) -> t.EngineCacheEntrySet {
  let field = types.Field(name: "loadEngineCacheEntrySetFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.EngineCacheEntrySet(op: types.Pure([field]))
}

/// Load a EngineCache from its ID.
pub fn load_engine_cache_from_i_d(id id: t.EngineCache) -> t.EngineCache {
  let field = types.Field(name: "loadEngineCacheFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.EngineCache(op: types.Pure([field]))
}

/// Load a Engine from its ID.
pub fn load_engine_from_i_d(id id: t.Engine) -> t.Engine {
  let field = types.Field(name: "loadEngineFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Engine(op: types.Pure([field]))
}

/// Load a EnumTypeDef from its ID.
pub fn load_enum_type_def_from_i_d(id id: t.EnumTypeDef) -> t.EnumTypeDef {
  let field = types.Field(name: "loadEnumTypeDefFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.EnumTypeDef(op: types.Pure([field]))
}

/// Load a EnumValueTypeDef from its ID.
pub fn load_enum_value_type_def_from_i_d(id id: t.EnumValueTypeDef) -> t.EnumValueTypeDef {
  let field = types.Field(name: "loadEnumValueTypeDefFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.EnumValueTypeDef(op: types.Pure([field]))
}

/// Load a EnvFile from its ID.
pub fn load_env_file_from_i_d(id id: t.EnvFile) -> t.EnvFile {
  let field = types.Field(name: "loadEnvFileFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.EnvFile(op: types.Pure([field]))
}

/// Load a Env from its ID.
pub fn load_env_from_i_d(id id: t.Env) -> t.Env {
  let field = types.Field(name: "loadEnvFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Env(op: types.Pure([field]))
}

/// Load a EnvVariable from its ID.
pub fn load_env_variable_from_i_d(id id: t.EnvVariable) -> t.EnvVariable {
  let field = types.Field(name: "loadEnvVariableFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.EnvVariable(op: types.Pure([field]))
}

/// Load a Error from its ID.
pub fn load_error_from_i_d(id id: t.Error) -> t.Error {
  let field = types.Field(name: "loadErrorFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Error(op: types.Pure([field]))
}

/// Load a ErrorValue from its ID.
pub fn load_error_value_from_i_d(id id: t.ErrorValue) -> t.ErrorValue {
  let field = types.Field(name: "loadErrorValueFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.ErrorValue(op: types.Pure([field]))
}

/// Load a FieldTypeDef from its ID.
pub fn load_field_type_def_from_i_d(id id: t.FieldTypeDef) -> t.FieldTypeDef {
  let field = types.Field(name: "loadFieldTypeDefFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.FieldTypeDef(op: types.Pure([field]))
}

/// Load a File from its ID.
pub fn load_file_from_i_d(id id: t.File) -> t.File {
  let field = types.Field(name: "loadFileFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.File(op: types.Pure([field]))
}

/// Load a FunctionArg from its ID.
pub fn load_function_arg_from_i_d(id id: t.FunctionArg) -> t.FunctionArg {
  let field = types.Field(name: "loadFunctionArgFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.FunctionArg(op: types.Pure([field]))
}

/// Load a FunctionCallArgValue from its ID.
pub fn load_function_call_arg_value_from_i_d(id id: t.FunctionCallArgValue) -> t.FunctionCallArgValue {
  let field = types.Field(name: "loadFunctionCallArgValueFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.FunctionCallArgValue(op: types.Pure([field]))
}

/// Load a FunctionCall from its ID.
pub fn load_function_call_from_i_d(id id: t.FunctionCall) -> t.FunctionCall {
  let field = types.Field(name: "loadFunctionCallFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.FunctionCall(op: types.Pure([field]))
}

/// Load a Function from its ID.
pub fn load_function_from_i_d(id id: t.Function) -> t.Function {
  let field = types.Field(name: "loadFunctionFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Function(op: types.Pure([field]))
}

/// Load a GeneratedCode from its ID.
pub fn load_generated_code_from_i_d(id id: t.GeneratedCode) -> t.GeneratedCode {
  let field = types.Field(name: "loadGeneratedCodeFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.GeneratedCode(op: types.Pure([field]))
}

/// Load a Generator from its ID.
pub fn load_generator_from_i_d(id id: t.Generator) -> t.Generator {
  let field = types.Field(name: "loadGeneratorFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Generator(op: types.Pure([field]))
}

/// Load a GeneratorGroup from its ID.
pub fn load_generator_group_from_i_d(id id: t.GeneratorGroup) -> t.GeneratorGroup {
  let field = types.Field(name: "loadGeneratorGroupFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.GeneratorGroup(op: types.Pure([field]))
}

/// Load a GitRef from its ID.
pub fn load_git_ref_from_i_d(id id: t.GitRef) -> t.GitRef {
  let field = types.Field(name: "loadGitRefFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.GitRef(op: types.Pure([field]))
}

/// Load a GitRepository from its ID.
pub fn load_git_repository_from_i_d(id id: t.GitRepository) -> t.GitRepository {
  let field = types.Field(name: "loadGitRepositoryFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.GitRepository(op: types.Pure([field]))
}

/// Load a Host from its ID.
pub fn load_host_from_i_d(id id: t.Host) -> t.Host {
  let field = types.Field(name: "loadHostFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Host(op: types.Pure([field]))
}

/// Load a InputTypeDef from its ID.
pub fn load_input_type_def_from_i_d(id id: t.InputTypeDef) -> t.InputTypeDef {
  let field = types.Field(name: "loadInputTypeDefFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.InputTypeDef(op: types.Pure([field]))
}

/// Load a InterfaceTypeDef from its ID.
pub fn load_interface_type_def_from_i_d(id id: t.InterfaceTypeDef) -> t.InterfaceTypeDef {
  let field = types.Field(name: "loadInterfaceTypeDefFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.InterfaceTypeDef(op: types.Pure([field]))
}

/// Load a JSONValue from its ID.
pub fn load_j_s_o_n_value_from_i_d(id id: t.JSONValue) -> t.JSONValue {
  let field = types.Field(name: "loadJSONValueFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.JSONValue(op: types.Pure([field]))
}

/// Load a LLM from its ID.
pub fn load_l_l_m_from_i_d(id id: t.LLM) -> t.LLM {
  let field = types.Field(name: "loadLLMFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.LLM(op: types.Pure([field]))
}

/// Load a LLMTokenUsage from its ID.
pub fn load_l_l_m_token_usage_from_i_d(id id: t.LLMTokenUsage) -> t.LLMTokenUsage {
  let field = types.Field(name: "loadLLMTokenUsageFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.LLMTokenUsage(op: types.Pure([field]))
}

/// Load a Label from its ID.
pub fn load_label_from_i_d(id id: t.Label) -> t.Label {
  let field = types.Field(name: "loadLabelFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Label(op: types.Pure([field]))
}

/// Load a ListTypeDef from its ID.
pub fn load_list_type_def_from_i_d(id id: t.ListTypeDef) -> t.ListTypeDef {
  let field = types.Field(name: "loadListTypeDefFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.ListTypeDef(op: types.Pure([field]))
}

/// Load a ModuleConfigClient from its ID.
pub fn load_module_config_client_from_i_d(id id: t.ModuleConfigClient) -> t.ModuleConfigClient {
  let field = types.Field(name: "loadModuleConfigClientFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.ModuleConfigClient(op: types.Pure([field]))
}

/// Load a Module from its ID.
pub fn load_module_from_i_d(id id: t.Module) -> t.Module {
  let field = types.Field(name: "loadModuleFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Module(op: types.Pure([field]))
}

/// Load a ModuleSource from its ID.
pub fn load_module_source_from_i_d(id id: t.ModuleSource) -> t.ModuleSource {
  let field = types.Field(name: "loadModuleSourceFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.ModuleSource(op: types.Pure([field]))
}

/// Load a ObjectTypeDef from its ID.
pub fn load_object_type_def_from_i_d(id id: t.ObjectTypeDef) -> t.ObjectTypeDef {
  let field = types.Field(name: "loadObjectTypeDefFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.ObjectTypeDef(op: types.Pure([field]))
}

/// Load a Port from its ID.
pub fn load_port_from_i_d(id id: t.Port) -> t.Port {
  let field = types.Field(name: "loadPortFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Port(op: types.Pure([field]))
}

/// Load a SDKConfig from its ID.
pub fn load_s_d_k_config_from_i_d(id id: t.SDKConfig) -> t.SDKConfig {
  let field = types.Field(name: "loadSDKConfigFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.SDKConfig(op: types.Pure([field]))
}

/// Load a ScalarTypeDef from its ID.
pub fn load_scalar_type_def_from_i_d(id id: t.ScalarTypeDef) -> t.ScalarTypeDef {
  let field = types.Field(name: "loadScalarTypeDefFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.ScalarTypeDef(op: types.Pure([field]))
}

/// Load a SearchResult from its ID.
pub fn load_search_result_from_i_d(id id: t.SearchResult) -> t.SearchResult {
  let field = types.Field(name: "loadSearchResultFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.SearchResult(op: types.Pure([field]))
}

/// Load a SearchSubmatch from its ID.
pub fn load_search_submatch_from_i_d(id id: t.SearchSubmatch) -> t.SearchSubmatch {
  let field = types.Field(name: "loadSearchSubmatchFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.SearchSubmatch(op: types.Pure([field]))
}

/// Load a Secret from its ID.
pub fn load_secret_from_i_d(id id: t.Secret) -> t.Secret {
  let field = types.Field(name: "loadSecretFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Secret(op: types.Pure([field]))
}

/// Load a Service from its ID.
pub fn load_service_from_i_d(id id: t.Service) -> t.Service {
  let field = types.Field(name: "loadServiceFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Service(op: types.Pure([field]))
}

/// Load a Socket from its ID.
pub fn load_socket_from_i_d(id id: t.Socket) -> t.Socket {
  let field = types.Field(name: "loadSocketFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Socket(op: types.Pure([field]))
}

/// Load a SourceMap from its ID.
pub fn load_source_map_from_i_d(id id: t.SourceMap) -> t.SourceMap {
  let field = types.Field(name: "loadSourceMapFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.SourceMap(op: types.Pure([field]))
}

/// Load a Stat from its ID.
pub fn load_stat_from_i_d(id id: t.Stat) -> t.Stat {
  let field = types.Field(name: "loadStatFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Stat(op: types.Pure([field]))
}

/// Load a Terminal from its ID.
pub fn load_terminal_from_i_d(id id: t.Terminal) -> t.Terminal {
  let field = types.Field(name: "loadTerminalFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Terminal(op: types.Pure([field]))
}

/// Load a TypeDef from its ID.
pub fn load_type_def_from_i_d(id id: t.TypeDef) -> t.TypeDef {
  let field = types.Field(name: "loadTypeDefFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.TypeDef(op: types.Pure([field]))
}

/// Load a Workspace from its ID.
pub fn load_workspace_from_i_d(id id: t.Workspace) -> t.Workspace {
  let field = types.Field(name: "loadWorkspaceFromID", args: [#("id", types.GDeferred(id.op))], subfields: [])
  t.Workspace(op: types.Pure([field]))
}

/// Create a new module.
pub fn module() -> t.Module {
  let field = types.Field(name: "module", args: [], subfields: [])
  t.Module(op: types.Pure([field]))
}

fn encode_module_source(opts: Opts(tag_)) -> List(#(String, types.Value)) {
  list.filter_map([
    case opts.ref_pin {
      Some(val) -> Ok(#("refPin", types.GString(val)))
      None -> Error(Nil)
    },
    case opts.disable_find_up {
      Some(val) -> Ok(#("disableFindUp", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.allow_not_exists {
      Some(val) -> Ok(#("allowNotExists", types.GBool(val)))
      None -> Error(Nil)
    },
    case opts.require_kind {
      Some(val) -> Ok(#("requireKind", types.GString(t.module_source_kind_to_json(val))))
      None -> Error(Nil)
    }
  ], fn(x) { x })
}

/// Create a new module source instance from a source ref string
pub fn module_source(ref_string ref_string: String, with with_fn: fn(Opts(ForModuleSource)) -> Opts(ForModuleSource)) -> t.ModuleSource {
  let opts = with_fn(defaults())
  let field = types.Field(name: "moduleSource", args: list.append([#("refString", types.GString(ref_string))], encode_module_source(opts)), subfields: [])
  t.ModuleSource(op: types.Pure([field]))
}

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

/// Creates a new secret.
pub fn secret(uri uri: String, with with_fn: fn(Opts(ForSecret)) -> Opts(ForSecret)) -> t.Secret {
  let opts = with_fn(defaults())
  let field = types.Field(name: "secret", args: list.append([#("uri", types.GString(uri))], encode_secret(opts)), subfields: [])
  t.Secret(op: types.Pure([field]))
}

/// Sets a secret given a user defined name to its plaintext and returns the secret.
/// The plaintext value is limited to a size of 128000 bytes.
pub fn set_secret(name name: String, plaintext plaintext: String) -> t.Secret {
  let field = types.Field(name: "setSecret", args: [#("name", types.GString(name)), #("plaintext", types.GString(plaintext))], subfields: [])
  t.Secret(op: types.Pure([field]))
}

/// Creates source map metadata.
pub fn source_map(filename filename: String, line line: Int, column column: Int) -> t.SourceMap {
  let field = types.Field(name: "sourceMap", args: [#("filename", types.GString(filename)), #("line", types.GInt(line)), #("column", types.GInt(column))], subfields: [])
  t.SourceMap(op: types.Pure([field]))
}

/// Create a new TypeDef.
pub fn type_def() -> t.TypeDef {
  let field = types.Field(name: "typeDef", args: [], subfields: [])
  t.TypeDef(op: types.Pure([field]))
}

/// Get the current Dagger Engine version.
pub fn version(client client: Client, then handler: fn(Try(String)) -> a) -> a {
  let field = types.Field(name: "version", args: [], subfields: [])
  let op = {
    use q <- types.bind(types.Pure([]))
    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("version")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}