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

Generic emission helpers for wrapper manifests.

# `callback_bridge_backlog_entry`

```elixir
@type callback_bridge_backlog_entry() :: %{
  function: Kinda.Wrapper.Function.t(),
  callback_bridge: Kinda.Wrapper.CallbackBridge.t()
}
```

# `callback_bridge_manifest`

```elixir
@type callback_bridge_manifest() :: %{
  required(String.t()) => pos_integer() | [callback_bridge_manifest_entry()]
}
```

# `callback_bridge_manifest_entry`

```elixir
@type callback_bridge_manifest_entry() :: %{
  required(String.t()) =>
    callback_bridge_manifest_function() | callback_bridge_manifest_metadata()
}
```

# `callback_bridge_manifest_function`

```elixir
@type callback_bridge_manifest_function() :: %{
  required(String.t()) =>
    String.t() | non_neg_integer() | boolean() | [String.t()] | nil
}
```

# `callback_bridge_manifest_metadata`

```elixir
@type callback_bridge_manifest_metadata() :: %{
  required(String.t()) => String.t() | [String.t()]
}
```

# `declaration_manifest`

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

# `declaration_manifest_struct`

```elixir
@type declaration_manifest_struct() :: Kinda.CodeGen.DeclarationManifest.t()
```

# `declaration_surfaces_struct`

```elixir
@type declaration_surfaces_struct() :: Kinda.CodeGen.DeclarationSurfaces.t()
```

# `signature_manifest`

```elixir
@type signature_manifest() :: %{
  required(String.t()) =>
    pos_integer() | [signature_manifest_entry()] | [signature_manifest_record()]
}
```

# `signature_manifest_entry`

```elixir
@type signature_manifest_entry() :: %{
  required(String.t()) =>
    signature_manifest_function()
    | [signature_manifest_variant()]
    | String.t()
    | nil
}
```

# `signature_manifest_function`

```elixir
@type signature_manifest_function() :: %{
  required(String.t()) =>
    String.t()
    | non_neg_integer()
    | [String.t() | nil]
    | map()
    | [map() | nil]
    | nil
}
```

# `signature_manifest_record`

```elixir
@type signature_manifest_record() :: %{
  required(String.t()) =>
    String.t() | map() | [signature_manifest_record_field()]
}
```

# `signature_manifest_record_field`

```elixir
@type signature_manifest_record_field() :: %{
  required(String.t()) => String.t() | map() | nil
}
```

# `signature_manifest_variant`

```elixir
@type signature_manifest_variant() :: %{
  required(String.t()) =>
    String.t() | false | [String.t()] | [map()] | map() | nil
}
```

# `callback_bridge_backlog`

```elixir
@spec callback_bridge_backlog(Kinda.Wrapper.Manifest.t(), module()) :: [
  callback_bridge_backlog_entry()
]
```

# `callback_bridge_manifest`

```elixir
@spec callback_bridge_manifest(Kinda.Wrapper.Manifest.t(), module()) ::
  callback_bridge_manifest()
```

# `declaration_manifest`

```elixir
@spec declaration_manifest(Kinda.Wrapper.Manifest.t(), module()) ::
  declaration_manifest()
```

# `declaration_manifest_struct`

```elixir
@spec declaration_manifest_struct(Kinda.Wrapper.Manifest.t(), module()) ::
  declaration_manifest_struct()
```

# `declaration_surfaces_struct`

```elixir
@spec declaration_surfaces_struct(Kinda.Wrapper.Manifest.t(), module()) ::
  declaration_surfaces_struct()
```

# `elixir_functions`

```elixir
@spec elixir_functions(Kinda.Wrapper.Manifest.t(), module()) :: [{atom(), [atom()]}]
```

# `elixir_nif_decls`

```elixir
@spec elixir_nif_decls(Kinda.Wrapper.Manifest.t(), module()) :: [
  Kinda.CodeGen.NIFDecl.t()
]
```

# `render_callback_bridge_report`

```elixir
@spec render_callback_bridge_report(Kinda.Wrapper.Manifest.t(), module()) ::
  String.t()
```

# `render_elixir_manifest`

```elixir
@spec render_elixir_manifest(Kinda.Wrapper.Manifest.t(), module()) :: String.t()
```

# `render_zig_nif_entries`

```elixir
@spec render_zig_nif_entries(Kinda.Wrapper.Manifest.t(), module()) :: String.t()
```

# `signature_manifest`

```elixir
@spec signature_manifest(Kinda.Wrapper.Manifest.t(), module()) :: signature_manifest()
```

# `write_callback_bridge_manifest`

```elixir
@spec write_callback_bridge_manifest(
  Kinda.Wrapper.Manifest.t(),
  module(),
  nil | String.t(),
  (callback_bridge_manifest() -> iodata())
) :: :ok
```

# `write_callback_bridge_report`

```elixir
@spec write_callback_bridge_report(
  Kinda.Wrapper.Manifest.t(),
  module(),
  nil | String.t()
) :: :ok
```

# `write_declaration_manifest`

```elixir
@spec write_declaration_manifest(
  Kinda.Wrapper.Manifest.t(),
  module(),
  nil | String.t(),
  (declaration_manifest() -> iodata())
) :: :ok
```

# `write_elixir_manifest`

```elixir
@spec write_elixir_manifest(Kinda.Wrapper.Manifest.t(), module(), nil | String.t()) ::
  :ok
```

# `write_signature_manifest`

```elixir
@spec write_signature_manifest(
  Kinda.Wrapper.Manifest.t(),
  module(),
  nil | String.t(),
  (signature_manifest() -> iodata())
) :: :ok
```

# `write_zig_nif_entries`

```elixir
@spec write_zig_nif_entries(Kinda.Wrapper.Manifest.t(), module(), nil | String.t()) ::
  :ok
```

# `zig_entries`

```elixir
@spec zig_entries(Kinda.Wrapper.Manifest.t(), module()) :: [String.t()]
```

---

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