# `Beaver.MLIR.ConversionTarget`

An owning, callback-safe MLIR dialect conversion target.

Static and dynamic legality rules are composed by MLIR. Dynamic callbacks
run in the process that registered them while the conversion itself runs on
the context's native worker pool.

# `legality`

```elixir
@type legality() :: :legal | :illegal | :no_opinion | boolean()
```

# `legality_callback`

```elixir
@type legality_callback() :: (Beaver.MLIR.Operation.t() -> legality())
```

# `t`

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

# `add_dynamically_legal_dialect`

```elixir
@spec add_dynamically_legal_dialect(t(), String.Chars.t(), legality_callback()) :: t()
```

# `add_dynamically_legal_op`

```elixir
@spec add_dynamically_legal_op(t(), String.Chars.t(), legality_callback()) :: t()
```

# `add_illegal_dialect`

```elixir
@spec add_illegal_dialect(t(), String.Chars.t()) :: t()
```

# `add_illegal_op`

```elixir
@spec add_illegal_op(t(), String.Chars.t()) :: t()
```

# `add_legal_dialect`

```elixir
@spec add_legal_dialect(t(), String.Chars.t()) :: t()
```

# `add_legal_op`

```elixir
@spec add_legal_op(t(), String.Chars.t()) :: t()
```

# `create`

```elixir
@spec create(
  Beaver.MLIR.Context.t(),
  keyword()
) :: t()
```

# `destroy`

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

# `make`

# `mark_recursively_legal`

```elixir
@spec mark_recursively_legal(t(), String.Chars.t(), legality_callback() | nil) :: t()
```

# `mark_unknown_dynamically_legal`

```elixir
@spec mark_unknown_dynamically_legal(t(), legality_callback()) :: t()
```

# `with`

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