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

Returns all pre-computed endpoint configs.

@spec __features__() :: map()

Returns the exchange capability map.

@spec __field_maps__() :: map()

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

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

Returns the exchange ID string.

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

Returns the exchange display name.

@spec __response_envelopes__() :: map()

Returns per-slot unified-method response envelope configs.

@spec __signing__() :: %{pattern: atom(), config: map()}

Returns the signing pattern and config for this exchange.

@spec __spec__() :: map()

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

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

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

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

Returns the full unified method → endpoint configs mapping.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.

@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 upstream normalization field map. Returns {:error, :no_field_map} when the slot is unmapped and {:error, {:unresolved, reason}} when upstream flagged it as not safely derivable. opts may carry :market for discriminated maps.