# `ExWapp.Client.Transport`
[🔗](https://github.com/elchemista/ex_wapp/blob/v0.1.5/lib/ex_wapp/client/transport.ex#L1)

Behaviour for high-level, runtime-neutral ExWapp client adapters.

The `Transport` name is retained for API compatibility, but this is not a
wire transport. The adapter is owned by the host application and connects the
public client API to a complete runtime, session, queue, or test double.

Production WhatsApp messaging should use `ExWapp.Client.Transport.Session`.
A raw WebSocket alone cannot implement this contract safely because it lacks
Signal sessions, device fanout, sender keys, retry, and synchronized state.

# `connect`

```elixir
@callback connect(ExWapp.Client.t()) :: {:ok, ExWapp.Client.t()} | {:error, term()}
```

# `create_contact`
*optional* 

```elixir
@callback create_contact(ExWapp.Client.t(), String.t(), String.t()) ::
  {:ok, ExWapp.Client.t()} | :ok | {:error, term()}
```

# `delete_contact`
*optional* 

```elixir
@callback delete_contact(ExWapp.Client.t(), String.t()) ::
  {:ok, ExWapp.Client.t()} | :ok | {:error, term()}
```

# `delete_messages`
*optional* 

```elixir
@callback delete_messages(ExWapp.Client.t(), String.t(), [String.t()]) ::
  {:ok, ExWapp.Client.t()} | :ok | {:error, term()}
```

# `disconnect`
*optional* 

```elixir
@callback disconnect(ExWapp.Client.t()) ::
  {:ok, ExWapp.Client.t()} | :ok | {:error, term()}
```

# `download_media`
*optional* 

```elixir
@callback download_media(ExWapp.Client.t(), ExWapp.Media.Ref.t(), keyword()) ::
  {:ok, ExWapp.Client.t(), ExWapp.Media.Download.t()} | {:error, term()}
```

# `get_call`
*optional* 

```elixir
@callback get_call(ExWapp.Client.t(), String.t()) ::
  {:ok, ExWapp.Call.t()} | {:error, term()}
```

# `get_chat`
*optional* 

```elixir
@callback get_chat(ExWapp.Client.t(), String.t()) ::
  {:ok, ExWapp.Chat.chat()} | {:error, term()}
```

# `get_contact`
*optional* 

```elixir
@callback get_contact(ExWapp.Client.t(), String.t()) ::
  {:ok, ExWapp.Contact.t() | nil} | {:error, term()}
```

# `get_messages`
*optional* 

```elixir
@callback get_messages(ExWapp.Client.t(), String.t(), keyword()) ::
  {:ok, [ExWapp.Chat.message()]} | {:error, term()}
```

# `list_calls`
*optional* 

```elixir
@callback list_calls(ExWapp.Client.t(), keyword()) ::
  {:ok, [ExWapp.Call.t()]} | {:error, term()}
```

# `list_chats`
*optional* 

```elixir
@callback list_chats(ExWapp.Client.t()) :: {:ok, [ExWapp.Chat.chat()]} | {:error, term()}
```

# `list_contacts`
*optional* 

```elixir
@callback list_contacts(ExWapp.Client.t()) ::
  {:ok, [ExWapp.Contact.t()]} | {:error, term()}
```

# `list_groups`
*optional* 

```elixir
@callback list_groups(ExWapp.Client.t()) :: {:ok, [ExWapp.Chat.chat()]} | {:error, term()}
```

# `pair`
*optional* 

```elixir
@callback pair(ExWapp.Client.t()) :: {:ok, ExWapp.Client.t(), term()} | {:error, term()}
```

# `receive_message`
*optional* 

```elixir
@callback receive_message(ExWapp.Client.t(), term(), keyword()) ::
  {:ok, ExWapp.Client.t(), [ExWapp.Event.t()]}
  | {:ok, [ExWapp.Event.t()]}
  | {:error, term()}
```

# `send_message`

```elixir
@callback send_message(ExWapp.Client.t(), ExWapp.Message.t()) ::
  {:ok, String.t()}
  | {:ok, ExWapp.Client.t(), String.t()}
  | {:error, ExWapp.Client.t(), term()}
  | {:error, term()}
```

# `stream_messages`
*optional* 

```elixir
@callback stream_messages(ExWapp.Client.t(), String.t(), keyword()) ::
  {:ok, Enumerable.t()} | {:error, term()}
```

# `sync_contacts`
*optional* 

```elixir
@callback sync_contacts(ExWapp.Client.t()) ::
  {:ok, ExWapp.Client.t()} | :ok | {:error, term()}
```

# `update_contact`
*optional* 

```elixir
@callback update_contact(ExWapp.Client.t(), String.t(), map() | keyword()) ::
  {:ok, ExWapp.Client.t()} | :ok | {:error, term()}
```

---

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