# `Selecto.Capabilities`

Shared capability request and decision helpers.

Selecto owns the shape of capability questions and answers, but host
applications remain responsible for policy truth. These helpers are small
value constructors for adapters, components, write paths, and API layers that
need to ask the same kind of question.

# `capability_id`

```elixir
@type capability_id() :: atom() | String.t()
```

# `context`

```elixir
@type context() :: map()
```

# `operation`

```elixir
@type operation() :: atom() | String.t()
```

# `resolver`

```elixir
@type resolver() ::
  module()
  | (Selecto.Capabilities.Request.t() -> term())
  | (Selecto.Capabilities.Request.t(), map() -> term())
  | {module(), atom()}
```

# `target`

```elixir
@type target() :: map()
```

# `allow`

```elixir
@spec allow(atom() | String.t(), map() | keyword()) ::
  Selecto.Capabilities.Decision.t()
```

Builds an allow decision.

# `decide`

```elixir
@spec decide(resolver() | nil, Selecto.Capabilities.Request.t(), keyword() | map()) ::
  Selecto.Capabilities.Decision.t()
```

Resolves one capability request through a host resolver.

Supported resolver shapes are:

- a one-arity function receiving the request
- a two-arity function receiving the request and resolver context
- a module implementing `Selecto.Capabilities.Resolver.decide/2`
- `{module, function}` where the function has arity 2

Resolver return values are normalized to `Selecto.Capabilities.Decision`.

# `decide_many`

```elixir
@spec decide_many(
  resolver() | nil,
  [Selecto.Capabilities.Request.t()],
  keyword() | map()
) :: [
  Selecto.Capabilities.Decision.t()
]
```

Resolves many capability requests.

Module resolvers can implement `decide_many/2` for a true batch path. Other
resolver shapes fall back to `decide/3` for each request while preserving
request order.

# `deny`

```elixir
@spec deny(atom() | String.t(), map() | keyword()) ::
  Selecto.Capabilities.Decision.t()
```

Builds a deny decision.

# `hidden`

```elixir
@spec hidden(atom() | String.t(), map() | keyword()) ::
  Selecto.Capabilities.Decision.t()
```

Builds a hidden deny decision.

# `not_applicable`

```elixir
@spec not_applicable(atom() | String.t(), map() | keyword()) ::
  Selecto.Capabilities.Decision.t()
```

Builds a not-applicable decision.

# `preview_only`

```elixir
@spec preview_only(atom() | String.t(), map() | keyword()) ::
  Selecto.Capabilities.Decision.t()
```

Builds a conditional preview-only decision.

# `request`

```elixir
@spec request(map() | keyword()) :: Selecto.Capabilities.Request.t()
```

Builds a capability request.

---

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