# `Foresight.Backend`
[🔗](https://github.com/fosferon/foresight/blob/v0.3.2/lib/foresight/backend.ex#L1)

Dispatch surface for storage backends.

Every public function in `Foresight` forwards to the configured backend
module implementing these callbacks. Each callback returns `t:result/0`:
`{:ok, term()}` or `{:error, %Foresight.Error{}}`.

# `result`

```elixir
@type result() :: {:ok, term()} | {:error, Foresight.Error.t()}
```

# `add_bank_background`

```elixir
@callback add_bank_background(Foresight.Context.t(), String.t(), String.t(), keyword()) ::
  result()
```

# `audit_log_stats`

```elixir
@callback audit_log_stats(Foresight.Context.t(), map(), keyword()) :: result()
```

# `bank_profile`

```elixir
@callback bank_profile(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `bank_stats`

```elixir
@callback bank_stats(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `cancel_operation`

```elixir
@callback cancel_operation(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `clear_bank_memories`

```elixir
@callback clear_bank_memories(Foresight.Context.t(), String.t(), map(), keyword()) ::
  result()
```

# `clear_memory_observations`

```elixir
@callback clear_memory_observations(
  Foresight.Context.t(),
  String.t(),
  String.t(),
  keyword()
) :: result()
```

# `clear_observations`

```elixir
@callback clear_observations(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `consolidate`

```elixir
@callback consolidate(Foresight.Context.t(), term(), keyword()) :: result()
```

# `create_directive`

```elixir
@callback create_directive(Foresight.Context.t(), String.t(), map(), keyword()) ::
  result()
```

# `create_mental_model`

```elixir
@callback create_mental_model(Foresight.Context.t(), String.t(), map(), keyword()) ::
  result()
```

# `create_webhook`

```elixir
@callback create_webhook(Foresight.Context.t(), String.t(), map(), keyword()) :: result()
```

# `delete_bank`

```elixir
@callback delete_bank(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `delete_directive`

```elixir
@callback delete_directive(Foresight.Context.t(), String.t(), String.t(), keyword()) ::
  result()
```

# `delete_document`

```elixir
@callback delete_document(Foresight.Context.t(), String.t(), String.t(), keyword()) ::
  result()
```

# `delete_memory`

```elixir
@callback delete_memory(Foresight.Context.t(), String.t(), String.t(), keyword()) ::
  result()
```

# `delete_mental_model`

```elixir
@callback delete_mental_model(Foresight.Context.t(), String.t(), String.t(), keyword()) ::
  result()
```

# `delete_webhook`

```elixir
@callback delete_webhook(Foresight.Context.t(), String.t(), String.t(), keyword()) ::
  result()
```

# `entity_graph`

```elixir
@callback entity_graph(Foresight.Context.t(), map(), keyword()) :: result()
```

# `export_bank_template`

```elixir
@callback export_bank_template(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `get_bank_config`

```elixir
@callback get_bank_config(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `get_chunk`

```elixir
@callback get_chunk(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `get_directive`

```elixir
@callback get_directive(Foresight.Context.t(), String.t(), String.t(), keyword()) ::
  result()
```

# `get_document`

```elixir
@callback get_document(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `get_entity`

```elixir
@callback get_entity(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `get_memory`

```elixir
@callback get_memory(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `get_memory_history`

```elixir
@callback get_memory_history(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `get_mental_model`

```elixir
@callback get_mental_model(
  Foresight.Context.t(),
  String.t(),
  String.t(),
  map(),
  keyword()
) :: result()
```

# `get_mental_model_history`

```elixir
@callback get_mental_model_history(
  Foresight.Context.t(),
  String.t(),
  String.t(),
  keyword()
) :: result()
```

# `get_operation`

```elixir
@callback get_operation(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `import_bank_template`

```elixir
@callback import_bank_template(Foresight.Context.t(), String.t(), map(), keyword()) ::
  result()
```

# `list_audit_logs`

```elixir
@callback list_audit_logs(Foresight.Context.t(), map(), keyword()) :: result()
```

# `list_banks`

```elixir
@callback list_banks(
  Foresight.Context.t(),
  keyword()
) :: result()
```

# `list_directives`

```elixir
@callback list_directives(Foresight.Context.t(), String.t(), map(), keyword()) :: result()
```

# `list_document_chunks`

```elixir
@callback list_document_chunks(Foresight.Context.t(), String.t(), map(), keyword()) ::
  result()
```

# `list_documents`

```elixir
@callback list_documents(Foresight.Context.t(), map(), keyword()) :: result()
```

# `list_entities`

```elixir
@callback list_entities(Foresight.Context.t(), map(), keyword()) :: result()
```

# `list_memories`

```elixir
@callback list_memories(Foresight.Context.t(), map(), keyword()) :: result()
```

# `list_mental_models`

```elixir
@callback list_mental_models(Foresight.Context.t(), String.t(), map(), keyword()) ::
  result()
```

# `list_operations`

```elixir
@callback list_operations(Foresight.Context.t(), map(), keyword()) :: result()
```

# `list_tags`

```elixir
@callback list_tags(Foresight.Context.t(), map(), keyword()) :: result()
```

# `list_webhook_deliveries`

```elixir
@callback list_webhook_deliveries(
  Foresight.Context.t(),
  String.t(),
  String.t(),
  map(),
  keyword()
) ::
  result()
```

# `list_webhooks`

```elixir
@callback list_webhooks(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `memories_timeseries`

```elixir
@callback memories_timeseries(
  Foresight.Context.t(),
  String.t(),
  String.t(),
  String.t(),
  keyword()
) ::
  result()
```

# `memory_graph`

```elixir
@callback memory_graph(Foresight.Context.t(), map(), keyword()) :: result()
```

# `patch_bank`

```elixir
@callback patch_bank(Foresight.Context.t(), String.t(), map(), keyword()) :: result()
```

# `put_bank`

```elixir
@callback put_bank(Foresight.Context.t(), String.t(), map(), keyword()) :: result()
```

# `recall`

```elixir
@callback recall(Foresight.Context.t(), term(), keyword()) :: result()
```

# `recover_consolidation`

```elixir
@callback recover_consolidation(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `reflect`

```elixir
@callback reflect(Foresight.Context.t(), term(), keyword()) :: result()
```

# `refresh_mental_model`

```elixir
@callback refresh_mental_model(Foresight.Context.t(), String.t(), String.t(), keyword()) ::
  result()
```

# `reprocess_document`

```elixir
@callback reprocess_document(Foresight.Context.t(), String.t(), String.t(), keyword()) ::
  result()
```

# `reset_bank_config`

```elixir
@callback reset_bank_config(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `retain`

```elixir
@callback retain(Foresight.Context.t(), term(), keyword()) :: result()
```

# `retain_files`

```elixir
@callback retain_files(Foresight.Context.t(), term(), keyword()) :: result()
```

# `retry_operation`

```elixir
@callback retry_operation(Foresight.Context.t(), String.t(), keyword()) :: result()
```

# `update_bank_config`

```elixir
@callback update_bank_config(Foresight.Context.t(), String.t(), map(), keyword()) ::
  result()
```

# `update_bank_disposition`

```elixir
@callback update_bank_disposition(Foresight.Context.t(), String.t(), map(), keyword()) ::
  result()
```

# `update_directive`

```elixir
@callback update_directive(
  Foresight.Context.t(),
  String.t(),
  String.t(),
  map(),
  keyword()
) :: result()
```

# `update_document`

```elixir
@callback update_document(Foresight.Context.t(), String.t(), String.t(), map(), keyword()) ::
  result()
```

# `update_mental_model`

```elixir
@callback update_mental_model(
  Foresight.Context.t(),
  String.t(),
  String.t(),
  map(),
  keyword()
) :: result()
```

# `update_webhook`

```elixir
@callback update_webhook(Foresight.Context.t(), String.t(), String.t(), map(), keyword()) ::
  result()
```

---

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