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 Opts {
  Opts(
    platform: Option(String),
    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 {
  Opts(
    platform: 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) -> Opts {
  opts
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn cache_key(opts: Opts, val: String) -> Opts {
  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) -> 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) -> Opts) -> 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))
}

/// 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) -> 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) -> Opts) -> 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) -> 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) -> Opts) -> 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) -> 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) -> Opts) -> 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) -> 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) -> Opts) -> 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) -> 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) -> Opts) -> 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]))
}

/// 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) -> 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) -> Opts) -> 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) -> 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) -> Opts) -> 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))
}