# `Kinda.Wrapper.Policy`
[🔗](https://github.com/beaver-lodge/kinda/blob/main/lib/wrapper/policy.ex#L1)

Consumer-facing policy contract for wrapper generation.

`Kinda.Wrapper.Extract` and `Kinda.Wrapper.Generate` stay generic.
Downstream projects provide the policy that decides:

- which extracted functions are generation-blocked
- which extracted functions require a future callback-bridge layer
- which public variants are emitted
- how Elixir arities and Zig NIF entries are derived
- how raw C param/return facts and record fields project into public types

The older `unsupported_*` callbacks remain as compatibility aliases, but they
are no longer the preferred public vocabulary for new policy code.

# `function_name`

```elixir
@type function_name() :: atom()
```

# `generation_blocker_reason`

```elixir
@type generation_blocker_reason() :: atom()
```

# `params`

```elixir
@type params() :: [atom()]
```

# `unsupported_reason`

```elixir
@type unsupported_reason() :: atom()
```

# `variant`

```elixir
@type variant() :: term()
```

# `callback_bridge`

```elixir
@callback callback_bridge(function_name()) :: Kinda.Wrapper.CallbackBridge.t() | nil
```

# `callback_bridge?`

```elixir
@callback callback_bridge?(function_name()) :: boolean()
```

# `callback_bridge_entries`

```elixir
@callback callback_bridge_entries() :: %{
  optional(function_name()) => Kinda.Wrapper.CallbackBridge.t()
}
```

# `dirty`

```elixir
@callback dirty(variant()) :: Kinda.CodeGen.NIFDecl.dirty()
```

# `doc`

```elixir
@callback doc(variant(), Kinda.Wrapper.Function.t()) :: String.t() | nil
```

# `elixir_params`

```elixir
@callback elixir_params(variant(), params()) :: params()
```

# `generation_blocked?`

```elixir
@callback generation_blocked?(function_name()) :: boolean()
```

# `generation_blocker_entries`

```elixir
@callback generation_blocker_entries() :: %{
  optional(function_name()) => generation_blocker_reason()
}
```

# `generation_blocker_reason`

```elixir
@callback generation_blocker_reason(function_name()) :: generation_blocker_reason() | nil
```

# `public_name`

```elixir
@callback public_name(variant()) :: atom()
```

# `typespec_field`
*optional* 

```elixir
@callback typespec_field(Kinda.Wrapper.CRecord.t(), Kinda.Wrapper.CField.t()) ::
  Kinda.CodeGen.TypeSpecRef.t()
```

# `typespec_params`
*optional* 

```elixir
@callback typespec_params(variant(), Kinda.Wrapper.Function.t()) :: [
  Kinda.CodeGen.TypeSpecRef.t()
]
```

# `typespec_record`
*optional* 

```elixir
@callback typespec_record(Kinda.Wrapper.CRecord.t()) :: Kinda.CodeGen.TypeSpecRef.t()
```

# `typespec_return`
*optional* 

```elixir
@callback typespec_return(variant(), Kinda.Wrapper.Function.t()) ::
  Kinda.CodeGen.TypeSpecRef.t()
```

# `unsupported?`
*optional* 

```elixir
@callback unsupported?(function_name()) :: boolean()
```

# `unsupported_entries`
*optional* 

```elixir
@callback unsupported_entries() :: %{optional(function_name()) => unsupported_reason()}
```

# `unsupported_reason`
*optional* 

```elixir
@callback unsupported_reason(function_name()) :: unsupported_reason() | nil
```

# `variants`

```elixir
@callback variants(function_name()) :: [variant()]
```

# `zig_entry`

```elixir
@callback zig_entry(variant()) :: String.t()
```

---

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