# `LLMProxy.Limit`
[🔗](https://github.com/elixir-vibe/llm_proxy/blob/v0.3.1/lib/llm_proxy/limit.ex#L1)

Composable usage and runtime limits for API keys.

# `metric`

```elixir
@type metric() ::
  :concurrent_requests
  | :requests
  | :cache_write_tokens
  | :cache_read_tokens
  | :output_tokens
  | :input_tokens
  | :cost_usd
```

# `t`

```elixir
@type t() :: %LLMProxy.Limit{max: number(), metric: metric(), window: window() | nil}
```

# `window`

```elixir
@type window() :: :month | :week | :day | :four_hours | :hour | :minute
```

# `cache_read_tokens`

```elixir
@spec cache_read_tokens(window(), non_neg_integer()) :: t()
```

# `cache_write_tokens`

```elixir
@spec cache_write_tokens(window(), non_neg_integer()) :: t()
```

# `check`

```elixir
@spec check(map()) :: :ok | {:error, String.t()}
```

# `concurrent_request_limit`

```elixir
@spec concurrent_request_limit(map()) :: non_neg_integer() | nil
```

Returns the most restrictive concurrent-request limit for an API key.

Concurrent limits do not use a stored usage window. Runtime admission uses
this value without a storage query.

# `concurrent_requests`

```elixir
@spec concurrent_requests(non_neg_integer()) :: t()
```

# `cost`

```elixir
@spec cost(window(), number()) :: t()
```

# `input_tokens`

```elixir
@spec input_tokens(window(), non_neg_integer()) :: t()
```

# `new`

```elixir
@spec new(metric(), window() | nil, number()) :: t()
```

# `normalize`

```elixir
@spec normalize(term()) :: {:ok, [t()]} | {:error, String.t()}
```

# `output_tokens`

```elixir
@spec output_tokens(window(), non_neg_integer()) :: t()
```

# `requests`

```elixir
@spec requests(window(), non_neg_integer()) :: t()
```

# `valid?`

```elixir
@spec valid?(term()) :: boolean()
```

---

*Consult [api-reference.md](api-reference.md) for complete listing*