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(
    include: Option(List(String)),
  )
}

fn defaults() -> Opts {
  Opts(
    include: None,
  )
}

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

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

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

/// Return the check with the given name from the installed modules. Must match exactly one check.
pub fn check(parent: t.Env, name name: String) -> t.Check {
  let field = types.Field(name: "check", args: [#("name", types.GString(name))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Check(op: new_op)
}

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

/// Return all checks defined by the installed modules
pub fn checks(parent: t.Env, with with_fn: fn(Opts) -> Opts) -> t.CheckGroup {
  let opts = with_fn(defaults())
  let field = types.Field(name: "checks", args: encode_checks(opts), subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.CheckGroup(op: new_op)
}

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

/// Retrieves an input binding by name
pub fn input(parent: t.Env, name name: String) -> t.Binding {
  let field = types.Field(name: "input", args: [#("name", types.GString(name))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Binding(op: new_op)
}

/// Returns all input bindings provided to the environment
pub fn inputs(parent: t.Env, select select: fn(t.Binding) -> List(types.Field), client client: Client, then handler: fn(Try(List(t.Binding))) -> a) -> a {
  let subfields = select(t.Binding(op: types.Pure([])))
  let field = types.Field(name: "inputs", args: [], 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.Binding(op: types.Pure(full_query)) })))
          Error(_) -> types.Pure(Error(types.DecodingError("inputs")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

/// Retrieves an output binding by name
pub fn output(parent: t.Env, name name: String) -> t.Binding {
  let field = types.Field(name: "output", args: [#("name", types.GString(name))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Binding(op: new_op)
}

/// Returns all declared output bindings for the environment
pub fn outputs(parent: t.Env, select select: fn(t.Binding) -> List(types.Field), client client: Client, then handler: fn(Try(List(t.Binding))) -> a) -> a {
  let subfields = select(t.Binding(op: types.Pure([])))
  let field = types.Field(name: "outputs", args: [], 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.Binding(op: types.Pure(full_query)) })))
          Error(_) -> types.Pure(Error(types.DecodingError("outputs")))
        }
      }
    )
  }
  handler(interpreter.run(op, client))
}

/// Create or update a binding of type Address in the environment
pub fn with_address_input(parent: t.Env, name name: String, value value: t.Address, description description: String) -> t.Env {
  let field = types.Field(name: "withAddressInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Address output to be assigned in the environment
pub fn with_address_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withAddressOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type CacheVolume in the environment
pub fn with_cache_volume_input(parent: t.Env, name name: String, value value: t.CacheVolume, description description: String) -> t.Env {
  let field = types.Field(name: "withCacheVolumeInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired CacheVolume output to be assigned in the environment
pub fn with_cache_volume_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withCacheVolumeOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Changeset in the environment
pub fn with_changeset_input(parent: t.Env, name name: String, value value: t.Changeset, description description: String) -> t.Env {
  let field = types.Field(name: "withChangesetInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Changeset output to be assigned in the environment
pub fn with_changeset_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withChangesetOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type CheckGroup in the environment
pub fn with_check_group_input(parent: t.Env, name name: String, value value: t.CheckGroup, description description: String) -> t.Env {
  let field = types.Field(name: "withCheckGroupInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired CheckGroup output to be assigned in the environment
pub fn with_check_group_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withCheckGroupOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Check in the environment
pub fn with_check_input(parent: t.Env, name name: String, value value: t.Check, description description: String) -> t.Env {
  let field = types.Field(name: "withCheckInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Check output to be assigned in the environment
pub fn with_check_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withCheckOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Cloud in the environment
pub fn with_cloud_input(parent: t.Env, name name: String, value value: t.Cloud, description description: String) -> t.Env {
  let field = types.Field(name: "withCloudInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Cloud output to be assigned in the environment
pub fn with_cloud_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withCloudOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Container in the environment
pub fn with_container_input(parent: t.Env, name name: String, value value: t.Container, description description: String) -> t.Env {
  let field = types.Field(name: "withContainerInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Container output to be assigned in the environment
pub fn with_container_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withContainerOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Installs the current module into the environment, exposing its functions to the model
/// Contextual path arguments will be populated using the environment's workspace.
pub fn with_current_module(parent: t.Env) -> t.Env {
  let field = types.Field(name: "withCurrentModule", args: [], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Directory in the environment
pub fn with_directory_input(parent: t.Env, name name: String, value value: t.Directory, description description: String) -> t.Env {
  let field = types.Field(name: "withDirectoryInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Directory output to be assigned in the environment
pub fn with_directory_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withDirectoryOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type EnvFile in the environment
pub fn with_env_file_input(parent: t.Env, name name: String, value value: t.EnvFile, description description: String) -> t.Env {
  let field = types.Field(name: "withEnvFileInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired EnvFile output to be assigned in the environment
pub fn with_env_file_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withEnvFileOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Env in the environment
pub fn with_env_input(parent: t.Env, name name: String, value value: t.Env, description description: String) -> t.Env {
  let field = types.Field(name: "withEnvInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Env output to be assigned in the environment
pub fn with_env_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withEnvOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type File in the environment
pub fn with_file_input(parent: t.Env, name name: String, value value: t.File, description description: String) -> t.Env {
  let field = types.Field(name: "withFileInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired File output to be assigned in the environment
pub fn with_file_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withFileOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type GeneratorGroup in the environment
pub fn with_generator_group_input(parent: t.Env, name name: String, value value: t.GeneratorGroup, description description: String) -> t.Env {
  let field = types.Field(name: "withGeneratorGroupInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired GeneratorGroup output to be assigned in the environment
pub fn with_generator_group_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withGeneratorGroupOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Generator in the environment
pub fn with_generator_input(parent: t.Env, name name: String, value value: t.Generator, description description: String) -> t.Env {
  let field = types.Field(name: "withGeneratorInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Generator output to be assigned in the environment
pub fn with_generator_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withGeneratorOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type GitRef in the environment
pub fn with_git_ref_input(parent: t.Env, name name: String, value value: t.GitRef, description description: String) -> t.Env {
  let field = types.Field(name: "withGitRefInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired GitRef output to be assigned in the environment
pub fn with_git_ref_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withGitRefOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type GitRepository in the environment
pub fn with_git_repository_input(parent: t.Env, name name: String, value value: t.GitRepository, description description: String) -> t.Env {
  let field = types.Field(name: "withGitRepositoryInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired GitRepository output to be assigned in the environment
pub fn with_git_repository_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withGitRepositoryOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type JSONValue in the environment
pub fn with_j_s_o_n_value_input(parent: t.Env, name name: String, value value: t.JSONValue, description description: String) -> t.Env {
  let field = types.Field(name: "withJSONValueInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired JSONValue output to be assigned in the environment
pub fn with_j_s_o_n_value_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withJSONValueOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Sets the main module for this environment (the project being worked on)
/// Contextual path arguments will be populated using the environment's workspace.
pub fn with_main_module(parent: t.Env, module module: t.Module) -> t.Env {
  let field = types.Field(name: "withMainModule", args: [#("module", types.GDeferred(module.op))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type ModuleConfigClient in the environment
pub fn with_module_config_client_input(parent: t.Env, name name: String, value value: t.ModuleConfigClient, description description: String) -> t.Env {
  let field = types.Field(name: "withModuleConfigClientInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired ModuleConfigClient output to be assigned in the environment
pub fn with_module_config_client_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withModuleConfigClientOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Module in the environment
pub fn with_module_input(parent: t.Env, name name: String, value value: t.Module, description description: String) -> t.Env {
  let field = types.Field(name: "withModuleInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Module output to be assigned in the environment
pub fn with_module_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withModuleOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type ModuleSource in the environment
pub fn with_module_source_input(parent: t.Env, name name: String, value value: t.ModuleSource, description description: String) -> t.Env {
  let field = types.Field(name: "withModuleSourceInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired ModuleSource output to be assigned in the environment
pub fn with_module_source_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withModuleSourceOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type SearchResult in the environment
pub fn with_search_result_input(parent: t.Env, name name: String, value value: t.SearchResult, description description: String) -> t.Env {
  let field = types.Field(name: "withSearchResultInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired SearchResult output to be assigned in the environment
pub fn with_search_result_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withSearchResultOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type SearchSubmatch in the environment
pub fn with_search_submatch_input(parent: t.Env, name name: String, value value: t.SearchSubmatch, description description: String) -> t.Env {
  let field = types.Field(name: "withSearchSubmatchInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired SearchSubmatch output to be assigned in the environment
pub fn with_search_submatch_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withSearchSubmatchOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Secret in the environment
pub fn with_secret_input(parent: t.Env, name name: String, value value: t.Secret, description description: String) -> t.Env {
  let field = types.Field(name: "withSecretInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Secret output to be assigned in the environment
pub fn with_secret_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withSecretOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Service in the environment
pub fn with_service_input(parent: t.Env, name name: String, value value: t.Service, description description: String) -> t.Env {
  let field = types.Field(name: "withServiceInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Service output to be assigned in the environment
pub fn with_service_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withServiceOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Socket in the environment
pub fn with_socket_input(parent: t.Env, name name: String, value value: t.Socket, description description: String) -> t.Env {
  let field = types.Field(name: "withSocketInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Socket output to be assigned in the environment
pub fn with_socket_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withSocketOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Create or update a binding of type Stat in the environment
pub fn with_stat_input(parent: t.Env, name name: String, value value: t.Stat, description description: String) -> t.Env {
  let field = types.Field(name: "withStatInput", args: [#("name", types.GString(name)), #("value", types.GDeferred(value.op)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declare a desired Stat output to be assigned in the environment
pub fn with_stat_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withStatOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Provides a string input binding to the environment
pub fn with_string_input(parent: t.Env, name name: String, value value: String, description description: String) -> t.Env {
  let field = types.Field(name: "withStringInput", args: [#("name", types.GString(name)), #("value", types.GString(value)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Declares a desired string output binding
pub fn with_string_output(parent: t.Env, name name: String, description description: String) -> t.Env {
  let field = types.Field(name: "withStringOutput", args: [#("name", types.GString(name)), #("description", types.GString(description))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Returns a new environment with the provided workspace
pub fn with_workspace(parent: t.Env, workspace workspace: t.Directory) -> t.Env {
  let field = types.Field(name: "withWorkspace", args: [#("workspace", types.GDeferred(workspace.op))], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}

/// Returns a new environment without any outputs
pub fn without_outputs(parent: t.Env) -> t.Env {
  let field = types.Field(name: "withoutOutputs", args: [], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Env(op: new_op)
}


pub fn workspace(parent: t.Env) -> t.Directory {
  let field = types.Field(name: "workspace", args: [], subfields: [])
  let new_op = {
    use q <- types.bind(parent.op)
    types.Pure(list.append(q, [field]))
  }
  t.Directory(op: new_op)
}