# `Beaver.MLIR.TypeConverter`

An owning MLIR type converter whose Elixir callbacks are safe across native
worker threads, process termination, and NIF upgrades.

Conversion callbacks may return one type (1:1), multiple types (1:N), an
empty list (type erasure), `:declined`, or `{:error, reason}`.

# `conversion_result`

```elixir
@type conversion_result() ::
  Beaver.MLIR.Type.t()
  | {:ok, Beaver.MLIR.Type.t()}
  | :declined
  | {:error, term()}
```

# `materialization_result`

```elixir
@type materialization_result() ::
  Beaver.MLIR.Value.t()
  | {:ok, Beaver.MLIR.Value.t()}
  | :declined
  | {:error, term()}
```

# `one_to_n_materialization_result`

```elixir
@type one_to_n_materialization_result() ::
  [Beaver.MLIR.Value.t()]
  | {:ok, [Beaver.MLIR.Value.t()]}
  | :declined
  | {:error, term()}
```

# `one_to_n_result`

```elixir
@type one_to_n_result() ::
  [Beaver.MLIR.Type.t()]
  | {:ok, [Beaver.MLIR.Type.t()]}
  | :declined
  | {:error, term()}
```

# `t`

```elixir
@type t() :: %Beaver.MLIR.TypeConverter{
  ref: term(),
  registration: term(),
  timeout_ms: term()
}
```

# `add_1_to_n_conversion`

```elixir
@spec add_1_to_n_conversion(t(), (Beaver.MLIR.Type.t() -> one_to_n_result())) :: t()
```

# `add_1_to_n_target_materialization`

```elixir
@spec add_1_to_n_target_materialization(
  t(),
  (Beaver.MLIR.RewriterBase.t(),
   [Beaver.MLIR.Type.t()],
   [Beaver.MLIR.Value.t()],
   Beaver.MLIR.Location.t(),
   Beaver.MLIR.Type.t()
   | nil ->
     one_to_n_materialization_result())
) :: t()
```

# `add_conversion`

```elixir
@spec add_conversion(t(), (Beaver.MLIR.Type.t() -> conversion_result())) :: t()
```

# `add_source_materialization`

```elixir
@spec add_source_materialization(
  t(),
  (Beaver.MLIR.RewriterBase.t(),
   Beaver.MLIR.Type.t(),
   [Beaver.MLIR.Value.t()],
   Beaver.MLIR.Location.t() ->
     materialization_result())
) :: t()
```

# `add_target_materialization`

```elixir
@spec add_target_materialization(
  t(),
  (Beaver.MLIR.RewriterBase.t(),
   Beaver.MLIR.Type.t(),
   [Beaver.MLIR.Value.t()],
   Beaver.MLIR.Location.t(),
   Beaver.MLIR.Type.t() ->
     materialization_result())
) :: t()
```

# `convert`

```elixir
@spec convert(t(), Beaver.MLIR.Type.t()) ::
  {:ok, Beaver.MLIR.Type.t()} | {:error, term()}
```

# `create`

```elixir
@spec create(keyword()) :: t()
```

# `destroy`

```elixir
@spec destroy(t()) :: :ok
```

# `make`

# `with`

```elixir
@spec with(
  keyword(),
  (t() -> result)
) :: result
when result: var
```