# `Bourse.Binance`
[🔗](https://github.com/ZenHive/bourse/blob/main/lib/bourse/exchanges.ex#L31)

Binance exchange client (`binance`).

Generated from the owned vendored spec at compile time. Provides raw
REST endpoint wrappers, unified-method mapping, and response parsers.

## Metadata

- Certified: `yes`
- Pro: `yes`

## Signing

Pattern: `hmac_sha256_query` — HMAC-SHA256 query signing

## Capabilities

- Enabled: `fetchTicker`, `fetchOrderBook`, `fetchOHLCV`, `fetchBalance`, `fetchPositions`, `createOrder`, `cancelOrder`, `fetchOpenOrders`, `fetchMyTrades`, `fetchFundingRate`, `fetchMarkets`, `fetchCurrencies` (122 total — see `__features__/0`)

## Credentials

Private endpoints require: `apiKey`, `secret`.

## Introspection

- `__endpoints__/0` — 789 raw REST endpoints
- `__unified_endpoints__/0` — unified method → endpoint mapping
- `__features__/0` / `__venue_support__/0` — provider-support declarations
- `__mapping_complete__/0` — Bourse implementation completeness
- `__verification__/0` — provider-verification state
- `__signing__/0` — resolved signing pattern and config

## Usage

    {:ok, exchange} = Bourse.Exchange.new("binance")
    endpoints = Bourse.Binance.__endpoints__()

## API Functions
| Function | Arity | Description | Param Kinds |
| --- | --- | --- | --- |

# `__endpoints__`

```elixir
@spec __endpoints__() :: [map()]
```

Returns all pre-computed endpoint configs.

# `__features__`

```elixir
@spec __features__() :: map()
```

Returns provider-support declarations (`true`, `false`, or `"emulated"`).

# `__field_maps__`

```elixir
@spec __field_maps__() :: map()
```

Returns the owned normalization field maps (per response-type slot).

# `__id__`

```elixir
@spec __id__() :: String.t()
```

Returns the exchange ID string.

# `__mapping_complete__`

```elixir
@spec __mapping_complete__() :: %{required(String.t()) => boolean()}
```

Returns whether each unified method has a complete Bourse mapping.

# `__name__`

```elixir
@spec __name__() :: String.t()
```

Returns the exchange display name.

# `__response_envelopes__`

```elixir
@spec __response_envelopes__() :: map()
```

Returns per-slot unified-method response envelope configs.

# `__signing__`

```elixir
@spec __signing__() :: %{pattern: atom() | nil, config: map()}
```

Returns the signing pattern and config for this exchange.

# `__spec__`

```elixir
@spec __spec__() :: map()
```

Returns the lean spec (runtime describe minus API tree).

# `__unified_endpoint__`

```elixir
@spec __unified_endpoint__(atom()) :: [map()]
```

Returns endpoint configs for a specific unified method, or `[]` if unknown.

# `__unified_endpoints__`

```elixir
@spec __unified_endpoints__() :: %{required(atom()) => [map()]}
```

Returns the full unified method → endpoint configs mapping.

# `__venue_support__`

```elixir
@spec __venue_support__() :: map()
```

Returns provider support independently of Bourse implementation. Same map as `__features__/0`.

# `__verification__`

```elixir
@spec __verification__() :: %{required(String.t()) => String.t()}
```

Returns each unified method's provider-verification state.

# `parse_account`

```elixir
@spec parse_account(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw account response into `Bourse.Account`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_adl_rank`

```elixir
@spec parse_adl_rank(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw adl_rank response into `Bourse.ADLRank`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_balance`

```elixir
@spec parse_balance(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw balance response into `Bourse.Balance`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_borrow_interest`

```elixir
@spec parse_borrow_interest(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw borrow_interest response into `Bourse.BorrowInterest`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_borrow_rate`

```elixir
@spec parse_borrow_rate(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw borrow_rate response into `Bourse.BorrowRate`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_conversion`

```elixir
@spec parse_conversion(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw conversion response into `Bourse.Conversion`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_currency`

```elixir
@spec parse_currency(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw currency response into `Bourse.Currency`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_deposit_address`

```elixir
@spec parse_deposit_address(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw deposit_address response into `Bourse.DepositAddress`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_funding_history`

```elixir
@spec parse_funding_history(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw funding_history response into `Bourse.FundingHistory`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_funding_rate`

```elixir
@spec parse_funding_rate(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw funding_rate response into `Bourse.FundingRate`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_funding_rate_history`

```elixir
@spec parse_funding_rate_history(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw funding_rate_history response into `Bourse.FundingRateHistory`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_greeks`

```elixir
@spec parse_greeks(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw greeks response into `Bourse.Greeks`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_last_price`

```elixir
@spec parse_last_price(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw last_price response into `Bourse.LastPrice`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_ledger_entry`

```elixir
@spec parse_ledger_entry(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw ledger_entry response into `Bourse.LedgerEntry`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_leverage`

```elixir
@spec parse_leverage(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw leverage response into `Bourse.Leverage`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_leverage_tiers`

```elixir
@spec parse_leverage_tiers(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw leverage_tiers response into `Bourse.LeverageTier`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_liquidation`

```elixir
@spec parse_liquidation(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw liquidation response into `Bourse.Liquidation`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_long_short_ratio`

```elixir
@spec parse_long_short_ratio(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw long_short_ratio response into `Bourse.LongShortRatio`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_margin_loan`

```elixir
@spec parse_margin_loan(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw margin_loan response into `Bourse.MarginLoan`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_margin_mode`

```elixir
@spec parse_margin_mode(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw margin_mode response into `Bourse.MarginMode`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_margin_modification`

```elixir
@spec parse_margin_modification(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw margin_modification response into `Bourse.MarginModification`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_market`

```elixir
@spec parse_market(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw market response into `Bourse.Market`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_ohlcv`

```elixir
@spec parse_ohlcv(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw ohlcv response into `Bourse.OHLCV`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_open_interest`

```elixir
@spec parse_open_interest(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw open_interest response into `Bourse.OpenInterest`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_option`

```elixir
@spec parse_option(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw option response into `Bourse.OptionData`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_order`

```elixir
@spec parse_order(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw order response into `Bourse.Order`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_order_list`

```elixir
@spec parse_order_list(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw order_list response into `Bourse.OrderList`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_position`

```elixir
@spec parse_position(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw position response into `Bourse.Position`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_ticker`

```elixir
@spec parse_ticker(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw ticker response into `Bourse.Ticker`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_trade`

```elixir
@spec parse_trade(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw trade response into `Bourse.Trade`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_trading_fee`

```elixir
@spec parse_trading_fee(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw trading_fee response into `Bourse.TradingFee`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_transaction`

```elixir
@spec parse_transaction(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw transaction response into `Bourse.Transaction`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_transfer`

```elixir
@spec parse_transfer(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw transfer response into `Bourse.TransferEntry`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

# `parse_volatility_history`

```elixir
@spec parse_volatility_history(
  term(),
  keyword()
) :: {:ok, struct() | [struct()]} | {:error, term()}
```

Parses a raw volatility_history response into `Bourse.VolatilityHistory`.

Delegates to `Bourse.Parser.parse/4` with this exchange's authored
normalization field map. Returns `{:error, {:unsupported_operation, slot}}`
when the provider does not offer the operation, `{:error, :no_field_map}`
when an offered slot is unmapped, and `{:error, {:unresolved, reason}}`
when the authored map is not safely derivable. `opts` may carry `:market`
for discriminated maps.
When the slot authors per-route field maps (`route_field_maps`), `opts`
MUST carry `:route` (the endpoint path template, e.g. `"account/bills"`);
an absent or unknown route returns `{:error, :no_matching_parser_branch}`
rather than silently parsing with the wrong vocabulary.

---

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