Ccxt.Transpiled.Runtime (CCXT Elixir v0.1.0-binance-pro-preview)

Copy Markdown View Source

Runtime helpers used by Elixir code generated from CCXT TypeScript methods.

Summary

Functions

abs_number_string(value)
account()
account(free, used, total)
add_number_strings(left, right)
add_or_concat(left, right)
amount_to_precision(exchange, symbol, amount)
array_concat(left, right)
array_concat(exchange, left, right)
base_describe(exchange)
call_generated!(module, function, args)
call_generated!(exchange, module, function, args)
call_raw!(raw_module, fetcher, function_name, list)
check_address(address)
check_required_argument(exchange, method_name, value, argument_name)
check_required_credentials(throw_on_error)
check_required_credentials(exchange, throw_on_error)
convert_expire_date(date)
convert_type_to_account(exchange, account)
create_safe_dictionary()
currency(exchange, code)
currency_to_precision(exchange, code, amount, network_code \\ nil)
decimal_to_precision(value, rounding_mode, precision, counting_mode, padding_mode \\ :no_padding)
decimal_to_precision(exchange, value, rounding_mode, precision, counting_mode, padding_mode)
deep_extend(left, right)
deep_extend(exchange, left, right)
deposit_withdraw_fee(exchange, info)
divide_number_string(left, right, precision \\ nil)
downcase(value)
eddsa(payload, secret, atom)
encode(value)
encode_uri_component(value)
error_instanceof?(type, expected)
extend(left, right)
fees(exchange)
fetch2(exchange, exchange_module, fetcher, path, api, method, params, headers, body, config)
fetch_paginated_call_deterministic(exchange, module, fetcher, method, symbol, since, limit, timeframe, params)
fetch_paginated_call_deterministic(exchange, module, fetcher, method, symbol, since, limit, timeframe, params, max_entries_per_request)
fetch_paginated_call_dynamic(exchange, module, fetcher, method, symbol, since, limit, params, max_entries_per_request \\ nil, remove_repeated \\ true)
fetch_paginated_call_incremental(exchange, module, fetcher, method, symbol, since, limit, params, page_key, max_entries_per_request \\ nil)
filter_by(values, key, wanted)
filter_by(exchange, values, key, wanted)
filter_by_array(values, key, allowed)
filter_by_array(exchange, values, key, allowed)
filter_by_array_positions(values, key, allowed, indexed \\ false)
filter_by_array_positions(exchange, values, key, allowed, indexed)
filter_by_currency_since_limit(values, code \\ nil, since \\ nil, limit \\ nil)
filter_by_since_limit(values, since \\ nil, limit \\ nil, key \\ "timestamp", tail \\ false)
filter_by_since_limit(exchange, values, since, limit, key, tail)
filter_by_symbol_since_limit(values, symbol \\ nil, since \\ nil, limit \\ nil)
get_market_from_symbols(exchange, arg2)
get_network_code_by_network_url(code, url)
handle_margin_mode_and_params(exchange, method_name, params, default_value \\ nil)
handle_market_type_and_params(exchange, method_name, market, params, default_value \\ nil)
handle_network_code_and_params(params)
handle_option_and_params2(exchange, params, method_name, option_name1, option_name2, default_value \\ nil)
handle_option_and_params(exchange, params, method_name, option_name, default_value \\ nil)
handle_sub_type_and_params(exchange, method_name, market_or_default, params)
handle_sub_type_and_params(exchange, method_name, market, params, default_sub_type)
handle_until_option(key, request, params, multiplier \\ 1)
handle_withdraw_tag_and_params(tag, params)
handle_withdraw_tag_and_params(exchange, tag, params)
has_key?(value, key)
hmac(payload, secret, atom)
in_array(value, values)
in_array(exchange, value, values)
index_by(values, key)
index_by(exchange, values, key)
index_of(value, needle)
index_range(size, start \\ 0)
inverse_type?(type, sub_type)
is_array(value)
is_array(namespace, value)
is_inverse(exchange, type, sub_type)
is_linear(exchange, type, sub_type)
is_post_only(is_market_order, exchange_specific_post_only, params)
is_round_number(value)
is_round_number(exchange, value)
iso8601(timestamp)
join(values, separator \\ "")
js_length(value)
json(exchange, value)
json_parse(value)
linear_type?(type, sub_type)
load_leverage_brackets(reload, params)
load_leverage_brackets(exchange, reload, params)
load_markets!(exchange)
load_markets!(exchange, module, fetcher)
load_time_difference()
load_time_difference(exchange)
mapped_string(mapping, key, default \\ nil)
market(markets, symbol)
market!(markets, symbol)
market_id(exchange, symbol)
market_ids(exchange, symbols)
market_symbols(exchange, symbols, type \\ nil, allow_empty \\ true, same_type_only \\ true, same_sub_type_only \\ true)
markets(exchange)
markets_state(markets)
milliseconds(exchange)
multiply_number_string(left, right)
network_code_to_id(network_code, currency_code)
network_id_to_code(network_id, currency_code)
new_error(type, arg2)
new_error_reason(type, arg2)
number_to_string(value)
number_to_string(exchange, value)
object_keys(value)
object_keys(namespace, value)
omit(value, key)
omit_zero(value)
parse8601(value)
parse_adl_ranks(exchange, module, ranks, symbols \\ nil, params \\ %{})
parse_all_greeks(exchange, module, greeks, symbols \\ nil, params \\ %{})
parse_balance(response)
parse_balance_custom(response, type, margin_mode, is_portfolio_margin)
parse_balance_custom(exchange, response, type, margin_mode, is_portfolio_margin)
parse_balance_helper(value)
parse_bids_asks(values, symbols \\ nil)
parse_borrow_interests(exchange, module, response, market \\ nil)
parse_borrow_rate_history(exchange, module, response, code, since \\ nil, limit \\ nil)
parse_conversions(exchange, module, values, code, from_currency_key, to_currency_key, since, limit)
parse_deposit_address(response, currency \\ nil)
parse_deposit_address(exchange, response, currency)
parse_deposit_withdraw_fee(exchange, fee, currency \\ nil)
parse_deposit_withdraw_fees(exchange, response, codes \\ nil, currency_id_key \\ nil)
parse_deposit_withdraw_fees(exchange, module, response, codes, currency_id_key)
parse_dust_trade(exchange, trade, market \\ nil)
parse_funding_rate(exchange, contract, market)
parse_funding_rate_histories(exchange, module, response, market, since \\ nil, limit \\ nil)
parse_funding_rates(exchange, values, symbols)
parse_funding_rates(exchange, module, values, symbols)
parse_incomes(exchange, module, response, market \\ nil, since \\ nil, limit \\ nil)
parse_int(value)
parse_isolated_borrow_rates(exchange, module, response)
parse_last_prices(values, symbols \\ nil)
parse_last_prices(exchange, values, symbols)
parse_ledger(values, currency \\ nil, since \\ nil, limit \\ nil)
parse_ledger(exchange, values, currency, since, limit)
parse_ledger(exchange, module, values, currency, since, limit)
parse_ledger_entry(item, currency \\ nil)
parse_ledger_entry(exchange, item, currency)
parse_ledger_entry_type(type)
parse_leverage(exchange, leverage, market \\ nil)
parse_leverage_tiers(exchange, response, symbols \\ nil, market_id_key \\ nil)
parse_leverage_tiers(exchange, module, response, symbols, market_id_key)
parse_leverages(exchange, response, symbols \\ nil, symbol_key \\ nil, market_type \\ nil)
parse_leverages(exchange, module, response, symbols, symbol_key, market_type)
parse_liquidations(exchange, module, values, market, since, limit)
parse_long_short_ratio_history(exchange, module, response, market, since \\ nil, limit \\ nil)
parse_margin_mode(exchange, margin_mode, market \\ nil)
parse_margin_modes(exchange, response, symbols \\ nil, symbol_key \\ nil, market_type \\ nil)
parse_margin_modes(exchange, module, response, symbols, symbol_key, market_type)
parse_margin_modifications(exchange, module, response, symbols \\ nil, symbol_key \\ nil, market_type \\ nil)
parse_market(market)
parse_market(exchange, market)
parse_market_leverage_tiers(exchange, info, market \\ nil)
parse_number(value)
parse_ohlcv(value)
parse_ohlcvs(values, since \\ nil, limit \\ nil)
parse_ohlcvs(values, market, timeframe, since, limit)
parse_open_interest(exchange, interest, market)
parse_open_interests_history(exchange, values, market)
parse_open_interests_history(exchange, module, values, market)
parse_open_interests_history(exchange, values, market, since, limit)
parse_open_interests_history(exchange, module, values, market, since, limit)
parse_option_position(exchange, position, market \\ nil)
parse_order(exchange, order, market \\ nil)
parse_order_book(value, symbol, timestamp, bids_key \\ "bids", asks_key \\ "asks", nonce \\ nil)
parse_order_status(status)
parse_order_type_by_market(type, market_type)
parse_orders(exchange, orders, market \\ nil, since \\ nil, limit \\ nil, params \\ %{})
parse_orders(exchange, module, orders, market, since, limit, params)
parse_precision(precision)
parse_precision(exchange, precision)
parse_spot_balance(response)
parse_spot_market(market)
parse_spot_markets(markets)
parse_ticker(value, market)
parse_ticker(value, symbol, exchange)
parse_tickers(values, symbols \\ nil, exchange \\ "binance")
parse_tickers(exchange, module, values, symbols)
parse_tickers_for_rolling(exchange, response, symbols)
parse_timeframe(exchange, timeframe)
parse_to_numeric(value)
parse_to_numeric(exchange, value)
parse_trade(trade, symbol_or_market)
parse_trades(values, symbol_or_market, since \\ nil, limit \\ nil)
parse_trades(exchange, module, values, symbol_or_market, since, limit)
parse_trading_fee(fee)
parse_trading_fee(exchange, fee)
parse_trading_fee(exchange, fee, market)
parse_transaction(transaction, currency \\ nil)
parse_transaction(exchange, transaction, currency)
parse_transaction_status_by_type(status, type)
parse_transactions(values, currency \\ nil, since \\ nil, limit \\ nil)
parse_transactions(exchange, values, currency, since, limit)
parse_transactions(exchange, module, values, currency, since, limit)
parse_transfers(exchange, module, values, currency, since, limit)
precision_from_string(value)
precision_from_string(exchange, value)
price_to_precision(exchange, symbol, price)
promise_all(values)
push(values, value)
put_symbols(params, symbols)
put_value(value, key, replacement)
put_value_in(value, path, replacement)
rawencode(params)
rsa(payload, secret, atom)
safe_balance(balance)
safe_bool2(value, key1, key2)
safe_bool2(value, key1, key2, default)
safe_bool(value, key, default \\ nil)
safe_bool_n(value, keys)
safe_currency(currency_id, currency \\ nil)
safe_currency_code(currency_id, currency \\ nil)
safe_currency_structure(currency)
safe_dict2(value, key1, key2, default \\ nil)
safe_dict2(exchange, value, key1, key2, default)
safe_dict(value, key, default \\ nil)
safe_dict(exchange, value, key, default)
safe_integer2(value, key1, key2, default \\ nil)
safe_integer(value, key, default \\ nil)
safe_integer_in(value, path, default \\ nil)
safe_integer_n(value, keys)
safe_integer_omit_zero(value, key)
safe_integer_product(value, key, factor, default \\ nil)
safe_integer_product_in(value, path, factor, default \\ nil)
safe_ledger_entry(entry, currency \\ nil)
safe_liquidation(liquidation)
safe_list2(value, key1, key2, default \\ nil)
safe_list2(exchange, value, key1, key2, default)
safe_list(value, key, default \\ nil)
safe_list(exchange, value, key, default)
safe_market(market_id, market, delimiter \\ nil, market_type \\ nil)
safe_market(exchange, market_id, market, delimiter, market_type)
safe_number2(value, key1, key2)
safe_number2(value, key1, key2, default)
safe_number(value, key)
safe_number(value, key, default)
safe_number_omit_zero(value, key)
safe_open_interest(open_interest, market)
safe_order(order, market \\ nil)
safe_position(exchange, position)
safe_string2(value, key1, key2, default \\ nil)
safe_string(value, key, default \\ nil)
safe_string_lower2(value, key1, key2, default \\ nil)
safe_string_lower(value, key, default \\ nil)
safe_string_n(value, keys)
safe_string_upper(value, key, default \\ nil)
safe_symbol(exchange, market_id, market)
safe_symbol(exchange, market_id, market, default)
safe_symbol(exchange, market_id, market, default, market_type)
safe_ticker(ticker, market \\ nil)
safe_timestamp(value, key, default \\ nil)
safe_trade(trade, market \\ nil)
safe_value2(value, key1, key2, default \\ nil)
safe_value(value, key, default \\ nil)
safe_value_in(value, path, default \\ nil)
set_sandbox_mode(exchange, enabled)
slice(value, start, stop \\ nil)
sort_by(values, key, descending \\ false, default \\ nil)
sort_by(exchange, values, key, descending, default)
status_from_equals(value, expected, ok_status, else_status)
string_eq?(left, right)
string_gt?(left, right)
string_lt?(left, right)
string_lte?(left, right)
string_split(value, separator)
subtract_number_strings(left, right)
sum(exchange, left, right)
take_exchange_options(exchange, params)
throw_broadly_matched_exception(exceptions, key, message)
throw_exactly_matched_exception(exceptions, key, message)
timeframe(exchange, value)
timeframes(exchange)
truthy(value)
typeof(value)
upcase(value)
urlencode(params)
urlencode_with_array_repeat(params)
uuid22()
yymmdd(timestamp)
yymmdd(exchange, timestamp)

Functions

abs_number_string(value)

@spec abs_number_string(term()) :: String.t() | nil

account()

@spec account() :: map()

account(free, used, total)

@spec account(term(), term(), term()) :: map()

add_number_strings(left, right)

@spec add_number_strings(term(), term()) :: String.t() | nil

add_or_concat(left, right)

@spec add_or_concat(term(), term()) :: term()

amount_to_precision(exchange, symbol, amount)

@spec amount_to_precision(map(), String.t(), number() | String.t()) ::
  String.t() | nil

array_concat(left, right)

@spec array_concat(list(), list()) :: list()

array_concat(exchange, left, right)

@spec array_concat(term(), list(), list()) :: list()

base_describe(exchange)

@spec base_describe(term()) :: map()

call_generated!(module, function, args)

@spec call_generated!(module(), atom(), list()) :: term()

call_generated!(exchange, module, function, args)

@spec call_generated!(map(), module(), atom(), list()) :: term()

call_raw!(raw_module, fetcher, function_name, list)

@spec call_raw!(
  module(),
  (term(), term() -> {:ok, term()} | {:error, term()}),
  String.t(),
  list()
) :: term()

check_address(address)

@spec check_address(String.t() | nil) :: :ok

check_required_argument(exchange, method_name, value, argument_name)

@spec check_required_argument(term(), String.t(), term(), String.t()) :: :ok

check_required_credentials(throw_on_error)

@spec check_required_credentials(boolean()) :: boolean()

check_required_credentials(exchange, throw_on_error)

@spec check_required_credentials(term(), boolean()) :: boolean()

convert_expire_date(date)

@spec convert_expire_date(String.t() | nil) :: String.t() | nil

convert_type_to_account(exchange, account)

@spec convert_type_to_account(map(), String.t()) :: String.t()

create_safe_dictionary()

@spec create_safe_dictionary() :: map()

currency(exchange, code)

@spec currency(map(), String.t()) :: map()
@spec currency(term(), String.t()) :: map()

currency_to_precision(exchange, code, amount, network_code \\ nil)

@spec currency_to_precision(
  map(),
  String.t(),
  number() | String.t(),
  String.t() | nil
) ::
  String.t() | nil

decimal_to_precision(value, rounding_mode, precision, counting_mode, padding_mode \\ :no_padding)

@spec decimal_to_precision(term(), term(), term(), term(), term()) :: String.t() | nil

decimal_to_precision(exchange, value, rounding_mode, precision, counting_mode, padding_mode)

@spec decimal_to_precision(term(), term(), term(), term(), term(), term()) ::
  String.t() | nil

deep_extend(left, right)

@spec deep_extend(map(), map() | keyword()) :: map()

deep_extend(exchange, left, right)

@spec deep_extend(term(), map(), map() | keyword()) :: map()

deposit_withdraw_fee(exchange, info)

@spec deposit_withdraw_fee(map(), map()) :: map()

divide_number_string(left, right, precision \\ nil)

@spec divide_number_string(term(), term(), non_neg_integer() | nil) ::
  String.t() | nil

downcase(value)

@spec downcase(String.t() | nil) :: String.t() | nil

eddsa(payload, secret, atom)

@spec eddsa(binary(), binary(), atom()) :: String.t()

encode(value)

@spec encode(term()) :: binary()

encode_uri_component(value)

@spec encode_uri_component(term()) :: String.t()

error_instanceof?(type, expected)

@spec error_instanceof?(term(), String.t()) :: boolean()

extend(left, right)

@spec extend(map(), map() | keyword()) :: map()

fees(exchange)

@spec fees(map()) :: map()

fetch2(exchange, exchange_module, fetcher, path, api, method, params, headers, body, config)

@spec fetch2(
  map(),
  module(),
  (term(), term() -> {:ok, term()} | {:error, term()}),
  term(),
  term(),
  term(),
  term(),
  term(),
  term(),
  term()
) :: term()

fetch_paginated_call_deterministic(exchange, module, fetcher, method, symbol, since, limit, timeframe, params)

fetch_paginated_call_deterministic(exchange, module, fetcher, method, symbol, since, limit, timeframe, params, max_entries_per_request)

@spec fetch_paginated_call_deterministic(
  term(),
  module(),
  function(),
  String.t(),
  term(),
  term(),
  term(),
  term(),
  term(),
  integer()
) :: list()

fetch_paginated_call_dynamic(exchange, module, fetcher, method, symbol, since, limit, params, max_entries_per_request \\ nil, remove_repeated \\ true)

@spec fetch_paginated_call_dynamic(
  term(),
  module(),
  function(),
  String.t(),
  term(),
  term(),
  term(),
  term(),
  integer() | nil,
  boolean()
) :: list()

fetch_paginated_call_incremental(exchange, module, fetcher, method, symbol, since, limit, params, page_key, max_entries_per_request \\ nil)

@spec fetch_paginated_call_incremental(
  term(),
  module(),
  function(),
  String.t(),
  term(),
  term(),
  term(),
  term(),
  String.t(),
  integer() | nil
) :: list()

filter_by(values, key, wanted)

filter_by(exchange, values, key, wanted)

@spec filter_by(term(), list(), atom() | String.t(), term()) :: list()

filter_by_array(values, key, allowed)

@spec filter_by_array(list(), String.t() | atom(), list() | nil) :: list()

filter_by_array(exchange, values, key, allowed)

@spec filter_by_array(term(), list(), String.t() | atom(), list() | nil) :: list()

filter_by_array_positions(values, key, allowed, indexed \\ false)

@spec filter_by_array_positions(list(), String.t() | atom(), list() | nil, boolean()) ::
  list()

filter_by_array_positions(exchange, values, key, allowed, indexed)

@spec filter_by_array_positions(
  term(),
  list(),
  String.t() | atom(),
  list() | nil,
  boolean()
) :: list()

filter_by_currency_since_limit(values, code \\ nil, since \\ nil, limit \\ nil)

@spec filter_by_currency_since_limit(
  list(),
  String.t() | nil,
  integer() | nil,
  integer() | nil
) ::
  list()

filter_by_since_limit(values, since \\ nil, limit \\ nil, key \\ "timestamp", tail \\ false)

filter_by_since_limit(exchange, values, since, limit, key, tail)

@spec filter_by_since_limit(
  term(),
  list(),
  integer() | nil,
  integer() | nil,
  atom() | String.t() | non_neg_integer(),
  boolean()
) :: list()

filter_by_symbol_since_limit(values, symbol \\ nil, since \\ nil, limit \\ nil)

@spec filter_by_symbol_since_limit(
  list(),
  String.t() | nil,
  integer() | nil,
  integer() | nil
) :: list()

get_market_from_symbols(exchange, arg2)

@spec get_market_from_symbols(map(), [String.t()] | nil) :: map() | nil

get_network_code_by_network_url(code, url)

@spec get_network_code_by_network_url(String.t() | nil, String.t() | nil) ::
  String.t() | nil

handle_margin_mode_and_params(exchange, method_name, params, default_value \\ nil)

@spec handle_margin_mode_and_params(map(), String.t(), map() | keyword(), term()) :: [
  String.t() | nil | map()
]

handle_market_type_and_params(exchange, method_name, market, params, default_value \\ nil)

@spec handle_market_type_and_params(
  map(),
  String.t(),
  map() | nil,
  map() | keyword(),
  term()
) :: [
  String.t() | nil | map()
]

handle_network_code_and_params(params)

@spec handle_network_code_and_params(map() | keyword()) :: [String.t() | nil | map()]

handle_option_and_params2(exchange, params, method_name, option_name1, option_name2, default_value \\ nil)

@spec handle_option_and_params2(
  map(),
  map() | keyword(),
  String.t(),
  String.t(),
  String.t(),
  term()
) :: [term() | map()]

handle_option_and_params(exchange, params, method_name, option_name, default_value \\ nil)

@spec handle_option_and_params(
  map(),
  map() | keyword(),
  String.t(),
  String.t(),
  term()
) :: [term() | map()]

handle_sub_type_and_params(exchange, method_name, market_or_default, params)

@spec handle_sub_type_and_params(
  term(),
  String.t(),
  String.t() | nil,
  map() | keyword()
) :: [
  String.t() | nil | map()
]

handle_sub_type_and_params(exchange, method_name, market, params, default_sub_type)

@spec handle_sub_type_and_params(
  term(),
  String.t(),
  map() | String.t() | nil,
  map() | keyword(),
  String.t() | nil
) :: [String.t() | nil | map()]

handle_until_option(key, request, params, multiplier \\ 1)

@spec handle_until_option(String.t(), map(), map() | keyword(), number()) :: [map()]

handle_withdraw_tag_and_params(tag, params)

@spec handle_withdraw_tag_and_params(term(), map() | keyword()) :: [
  String.t() | nil | map()
]

handle_withdraw_tag_and_params(exchange, tag, params)

@spec handle_withdraw_tag_and_params(map(), term(), map() | keyword()) :: [
  String.t() | nil | map()
]

has_key?(value, key)

@spec has_key?(term(), atom() | String.t()) :: boolean()

hmac(payload, secret, atom)

@spec hmac(binary(), binary(), atom()) :: String.t()

in_array(value, values)

@spec in_array(term(), list()) :: boolean()

in_array(exchange, value, values)

@spec in_array(term(), term(), list()) :: boolean()

index_by(values, key)

@spec index_by(list(), atom() | String.t()) :: map()

index_by(exchange, values, key)

@spec index_by(term(), list(), atom() | String.t()) :: map()

index_of(value, needle)

@spec index_of(String.t() | nil, String.t()) :: integer()

index_range(size, start \\ 0)

@spec index_range(non_neg_integer(), non_neg_integer()) :: [non_neg_integer()]

inverse_type?(type, sub_type)

@spec inverse_type?(String.t() | nil, String.t() | nil) :: boolean()

is_array(value)

@spec is_array(term()) :: boolean()

is_array(namespace, value)

@spec is_array(term(), term()) :: boolean()

is_inverse(exchange, type, sub_type)

@spec is_inverse(term(), String.t() | nil, String.t() | nil) :: boolean()

is_linear(exchange, type, sub_type)

@spec is_linear(term(), String.t() | nil, String.t() | nil) :: boolean()

is_post_only(is_market_order, exchange_specific_post_only, params)

@spec is_post_only(boolean(), boolean(), map() | keyword()) :: boolean()

is_round_number(value)

@spec is_round_number(number() | String.t() | nil) :: boolean()

is_round_number(exchange, value)

@spec is_round_number(term(), number() | String.t() | nil) :: boolean()

iso8601(timestamp)

@spec iso8601(integer() | nil) :: String.t() | nil

join(values, separator \\ "")

@spec join(term(), String.t()) :: String.t()

js_length(value)

@spec js_length(term()) :: non_neg_integer()

json(exchange, value)

@spec json(term(), term()) :: String.t()

json_parse(value)

@spec json_parse(String.t()) :: term()

linear_type?(type, sub_type)

@spec linear_type?(String.t() | nil, String.t() | nil) :: boolean()

load_leverage_brackets(reload, params)

@spec load_leverage_brackets(boolean(), map() | keyword()) :: :ok

load_leverage_brackets(exchange, reload, params)

@spec load_leverage_brackets(term(), boolean(), map() | keyword()) :: :ok

load_markets!(exchange)

@spec load_markets!(map()) :: map()

load_markets!(exchange, module, fetcher)

@spec load_markets!(map(), module(), function()) :: map()

load_time_difference()

@spec load_time_difference() :: :ok

load_time_difference(exchange)

@spec load_time_difference(term()) :: :ok

mapped_string(mapping, key, default \\ nil)

@spec mapped_string(map(), String.t() | nil, String.t() | nil) :: String.t() | nil

market(markets, symbol)

@spec market(map() | list(), String.t()) :: {:ok, map()} | {:error, term()}

market!(markets, symbol)

@spec market!(map() | list(), String.t()) :: map()

market_id(exchange, symbol)

@spec market_id(map() | String.t(), String.t()) :: String.t()

market_ids(exchange, symbols)

@spec market_ids(map(), [String.t()] | nil) :: [String.t()]

market_symbols(exchange, symbols, type \\ nil, allow_empty \\ true, same_type_only \\ true, same_sub_type_only \\ true)

@spec market_symbols(
  term(),
  [String.t()] | String.t() | nil,
  term(),
  boolean(),
  boolean(),
  boolean()
) :: [String.t()] | nil

markets(exchange)

@spec markets(map()) :: map()

markets_state(markets)

@spec markets_state(list()) :: map()

milliseconds(exchange)

@spec milliseconds(term()) :: integer()

multiply_number_string(left, right)

@spec multiply_number_string(term(), term()) :: String.t() | nil

network_code_to_id(network_code, currency_code)

@spec network_code_to_id(String.t() | nil, String.t() | nil) :: String.t() | nil

network_id_to_code(network_id, currency_code)

@spec network_id_to_code(String.t() | nil, String.t() | nil) :: String.t() | nil

new_error(type, arg2)

@spec new_error(String.t(), list()) :: String.t()

new_error_reason(type, arg2)

@spec new_error_reason(String.t(), list()) :: {atom(), String.t()}

number_to_string(value)

@spec number_to_string(term()) :: String.t() | nil

number_to_string(exchange, value)

@spec number_to_string(term(), term()) :: String.t() | nil

object_keys(value)

@spec object_keys(map() | keyword() | nil) :: list()

object_keys(namespace, value)

@spec object_keys(term(), map() | keyword() | nil) :: list()

omit(value, key)

@spec omit(map() | keyword(), [atom() | String.t()]) :: map() | keyword()

omit_zero(value)

@spec omit_zero(String.t() | number() | nil) :: String.t() | number() | nil

parse8601(value)

@spec parse8601(String.t() | nil) :: integer() | nil

parse_adl_ranks(exchange, module, ranks, symbols \\ nil, params \\ %{})

@spec parse_adl_ranks(map(), module(), list() | map(), [String.t()] | nil, map()) ::
  list()

parse_all_greeks(exchange, module, greeks, symbols \\ nil, params \\ %{})

@spec parse_all_greeks(map(), module(), list() | map(), [String.t()] | nil, map()) ::
  list()

parse_balance(response)

@spec parse_balance(term()) :: no_return()

parse_balance_custom(response, type, margin_mode, is_portfolio_margin)

parse_balance_custom(exchange, response, type, margin_mode, is_portfolio_margin)

@spec parse_balance_custom(
  map(),
  term(),
  String.t() | nil,
  String.t() | nil,
  boolean()
) :: map()

parse_balance_helper(value)

@spec parse_balance_helper(map()) :: map()

parse_bids_asks(values, symbols \\ nil)

@spec parse_bids_asks(list() | map(), [String.t()] | nil) :: map()

parse_borrow_interests(exchange, module, response, market \\ nil)

@spec parse_borrow_interests(map(), module(), list() | map(), map() | nil) :: list()

parse_borrow_rate_history(exchange, module, response, code, since \\ nil, limit \\ nil)

@spec parse_borrow_rate_history(
  map(),
  module(),
  list() | map(),
  String.t() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_conversions(exchange, module, values, code, from_currency_key, to_currency_key, since, limit)

@spec parse_conversions(
  term(),
  module(),
  list(),
  String.t() | nil,
  String.t() | nil,
  String.t() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_deposit_address(response, currency \\ nil)

@spec parse_deposit_address(map(), map() | nil) :: map()

parse_deposit_address(exchange, response, currency)

@spec parse_deposit_address(term(), map(), map() | nil) :: map()

parse_deposit_withdraw_fee(exchange, fee, currency \\ nil)

@spec parse_deposit_withdraw_fee(map(), map(), map() | nil) :: map()

parse_deposit_withdraw_fees(exchange, response, codes \\ nil, currency_id_key \\ nil)

@spec parse_deposit_withdraw_fees(
  map(),
  list() | map(),
  [String.t()] | nil,
  String.t() | nil
) :: map()

parse_deposit_withdraw_fees(exchange, module, response, codes, currency_id_key)

@spec parse_deposit_withdraw_fees(
  map(),
  module(),
  list() | map(),
  [String.t()] | nil,
  String.t() | nil
) :: map()

parse_dust_trade(exchange, trade, market \\ nil)

@spec parse_dust_trade(map(), map(), map() | nil) :: map()

parse_funding_rate(exchange, contract, market)

@spec parse_funding_rate(map(), map(), map() | nil) :: map()

parse_funding_rate_histories(exchange, module, response, market, since \\ nil, limit \\ nil)

@spec parse_funding_rate_histories(
  map(),
  module(),
  list() | map(),
  map() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_funding_rates(exchange, values, symbols)

@spec parse_funding_rates(map(), list(), [String.t()] | nil) :: map()

parse_funding_rates(exchange, module, values, symbols)

@spec parse_funding_rates(map(), module(), list() | map(), [String.t()] | nil) ::
  map()

parse_incomes(exchange, module, response, market \\ nil, since \\ nil, limit \\ nil)

@spec parse_incomes(
  map(),
  module(),
  list() | map(),
  map() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_int(value)

@spec parse_int(term()) :: integer() | nil

parse_isolated_borrow_rates(exchange, module, response)

@spec parse_isolated_borrow_rates(map(), module(), list() | map()) :: map()

parse_last_prices(values, symbols \\ nil)

@spec parse_last_prices(list() | map(), [String.t()] | nil) :: map()

parse_last_prices(exchange, values, symbols)

@spec parse_last_prices(map(), list() | map(), [String.t()] | nil) :: map()

parse_ledger(values, currency \\ nil, since \\ nil, limit \\ nil)

@spec parse_ledger(list(), map() | nil, integer() | nil, integer() | nil) :: list()

parse_ledger(exchange, values, currency, since, limit)

@spec parse_ledger(term(), list(), map() | nil, integer() | nil, integer() | nil) ::
  list()

parse_ledger(exchange, module, values, currency, since, limit)

@spec parse_ledger(
  term(),
  module(),
  list(),
  map() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_ledger_entry(item, currency \\ nil)

@spec parse_ledger_entry(map(), map() | nil) :: map()

parse_ledger_entry(exchange, item, currency)

@spec parse_ledger_entry(term(), map(), map() | nil) :: map()

parse_ledger_entry_type(type)

@spec parse_ledger_entry_type(String.t() | nil) :: String.t() | nil

parse_leverage(exchange, leverage, market \\ nil)

@spec parse_leverage(map(), map(), map() | nil) :: map()

parse_leverage_tiers(exchange, response, symbols \\ nil, market_id_key \\ nil)

@spec parse_leverage_tiers(
  map(),
  list() | map(),
  [String.t()] | nil,
  String.t() | nil
) :: map()

parse_leverage_tiers(exchange, module, response, symbols, market_id_key)

@spec parse_leverage_tiers(
  map(),
  module(),
  list() | map(),
  [String.t()] | nil,
  String.t() | nil
) :: map()

parse_leverages(exchange, response, symbols \\ nil, symbol_key \\ nil, market_type \\ nil)

@spec parse_leverages(
  map(),
  list(),
  [String.t()] | nil,
  String.t() | nil,
  String.t() | nil
) :: map()

parse_leverages(exchange, module, response, symbols, symbol_key, market_type)

@spec parse_leverages(
  map(),
  module(),
  list(),
  [String.t()] | nil,
  String.t() | nil,
  String.t() | nil
) :: map()

parse_liquidations(exchange, module, values, market, since, limit)

@spec parse_liquidations(
  term(),
  module(),
  list(),
  map() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_long_short_ratio_history(exchange, module, response, market, since \\ nil, limit \\ nil)

@spec parse_long_short_ratio_history(
  map(),
  module(),
  list() | map(),
  map() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_margin_mode(exchange, margin_mode, market \\ nil)

@spec parse_margin_mode(map(), map(), map() | nil) :: map()

parse_margin_modes(exchange, response, symbols \\ nil, symbol_key \\ nil, market_type \\ nil)

@spec parse_margin_modes(
  map(),
  list(),
  [String.t()] | nil,
  String.t() | nil,
  String.t() | nil
) :: map()

parse_margin_modes(exchange, module, response, symbols, symbol_key, market_type)

@spec parse_margin_modes(
  map(),
  module(),
  list(),
  [String.t()] | nil,
  String.t() | nil,
  String.t() | nil
) :: map()

parse_margin_modifications(exchange, module, response, symbols \\ nil, symbol_key \\ nil, market_type \\ nil)

@spec parse_margin_modifications(
  map(),
  module(),
  list() | map(),
  [String.t()] | nil,
  String.t() | nil,
  String.t() | nil
) :: list()

parse_market(market)

@spec parse_market(map()) :: map()

parse_market(exchange, market)

@spec parse_market(term(), map()) :: map()

parse_market_leverage_tiers(exchange, info, market \\ nil)

@spec parse_market_leverage_tiers(map(), map(), map() | nil) :: list()

parse_number(value)

@spec parse_number(term()) :: number() | nil

parse_ohlcv(value)

@spec parse_ohlcv(list() | map()) :: list()

parse_ohlcvs(values, since \\ nil, limit \\ nil)

@spec parse_ohlcvs(list(), integer() | nil, integer() | nil) :: list()

parse_ohlcvs(values, market, timeframe, since, limit)

@spec parse_ohlcvs(list(), map() | nil, String.t(), integer() | nil, integer() | nil) ::
  list()

parse_open_interest(exchange, interest, market)

@spec parse_open_interest(map(), map(), map() | nil) :: map()

parse_open_interests_history(exchange, values, market)

@spec parse_open_interests_history(map(), list(), map() | nil) :: list()

parse_open_interests_history(exchange, module, values, market)

@spec parse_open_interests_history(map(), module(), list(), map() | nil) :: list()

parse_open_interests_history(exchange, values, market, since, limit)

@spec parse_open_interests_history(
  map(),
  list(),
  map() | nil,
  integer() | nil,
  integer() | nil
) ::
  list()

parse_open_interests_history(exchange, module, values, market, since, limit)

@spec parse_open_interests_history(
  map(),
  module(),
  list(),
  map() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_option_position(exchange, position, market \\ nil)

@spec parse_option_position(map(), map(), map() | nil) :: map()

parse_order(exchange, order, market \\ nil)

@spec parse_order(map(), map(), map() | nil) :: map()

parse_order_book(value, symbol, timestamp, bids_key \\ "bids", asks_key \\ "asks", nonce \\ nil)

@spec parse_order_book(
  map(),
  String.t(),
  integer() | nil,
  String.t(),
  String.t(),
  integer() | nil
) :: map()

parse_order_status(status)

@spec parse_order_status(String.t() | nil) :: String.t() | nil

parse_order_type_by_market(type, market_type)

@spec parse_order_type_by_market(String.t() | nil, String.t() | nil) ::
  String.t() | nil

parse_orders(exchange, orders, market \\ nil, since \\ nil, limit \\ nil, params \\ %{})

@spec parse_orders(
  map(),
  term(),
  map() | nil,
  integer() | nil,
  integer() | nil,
  map()
) :: list()

parse_orders(exchange, module, orders, market, since, limit, params)

@spec parse_orders(
  map(),
  module(),
  term(),
  map() | nil,
  integer() | nil,
  integer() | nil,
  map()
) :: list()

parse_precision(precision)

@spec parse_precision(term()) :: String.t() | nil

parse_precision(exchange, precision)

@spec parse_precision(term(), term()) :: String.t() | nil

parse_spot_balance(response)

@spec parse_spot_balance(map()) :: map()

parse_spot_market(market)

@spec parse_spot_market(map()) :: map()

parse_spot_markets(markets)

@spec parse_spot_markets(list()) :: list()

parse_ticker(value, market)

parse_ticker(value, symbol, exchange)

@spec parse_ticker(map(), String.t(), String.t()) :: map()

parse_tickers(values, symbols \\ nil, exchange \\ "binance")

@spec parse_tickers(list() | map(), [String.t()] | nil, String.t()) :: map()

parse_tickers(exchange, module, values, symbols)

@spec parse_tickers(map(), module(), list() | map(), [String.t()] | nil) :: map()

parse_tickers_for_rolling(exchange, response, symbols)

@spec parse_tickers_for_rolling(map(), list(), [String.t()] | nil) :: map()

parse_timeframe(exchange, timeframe)

@spec parse_timeframe(term(), String.t()) :: integer()

parse_to_numeric(value)

@spec parse_to_numeric(term()) :: integer() | float() | nil

parse_to_numeric(exchange, value)

@spec parse_to_numeric(term(), term()) :: integer() | float() | nil

parse_trade(trade, symbol_or_market)

@spec parse_trade(map(), String.t() | map() | nil) :: map()

parse_trades(values, symbol_or_market, since \\ nil, limit \\ nil)

@spec parse_trades(list(), String.t() | map() | nil, integer() | nil, integer() | nil) ::
  list()

parse_trades(exchange, module, values, symbol_or_market, since, limit)

@spec parse_trades(
  map(),
  module(),
  list(),
  map() | String.t() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_trading_fee(fee)

@spec parse_trading_fee(map()) :: map()

parse_trading_fee(exchange, fee)

@spec parse_trading_fee(map(), map() | nil) :: map()

parse_trading_fee(exchange, fee, market)

@spec parse_trading_fee(term(), map(), map() | nil) :: map()

parse_transaction(transaction, currency \\ nil)

@spec parse_transaction(map(), map() | nil) :: map()

parse_transaction(exchange, transaction, currency)

@spec parse_transaction(term(), map(), map() | nil) :: map()

parse_transaction_status_by_type(status, type)

@spec parse_transaction_status_by_type(String.t() | nil, String.t() | nil) ::
  String.t() | nil

parse_transactions(values, currency \\ nil, since \\ nil, limit \\ nil)

@spec parse_transactions(list(), map() | nil, integer() | nil, integer() | nil) ::
  list()

parse_transactions(exchange, values, currency, since, limit)

@spec parse_transactions(
  term(),
  list(),
  map() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_transactions(exchange, module, values, currency, since, limit)

@spec parse_transactions(
  term(),
  module(),
  list(),
  map() | nil,
  integer() | nil,
  integer() | nil
) :: list()

parse_transfers(exchange, module, values, currency, since, limit)

@spec parse_transfers(
  term(),
  module(),
  list(),
  map() | nil,
  integer() | nil,
  integer() | nil
) :: list()

precision_from_string(value)

@spec precision_from_string(String.t() | number() | nil) :: non_neg_integer() | nil

precision_from_string(exchange, value)

@spec precision_from_string(term(), String.t() | number() | nil) ::
  non_neg_integer() | nil

price_to_precision(exchange, symbol, price)

@spec price_to_precision(map(), String.t(), number() | String.t()) :: String.t() | nil

promise_all(values)

@spec promise_all(list()) :: list()

push(values, value)

@spec push(list(), term()) :: list()

put_symbols(params, symbols)

@spec put_symbols(map() | keyword(), [String.t()] | nil) :: map()

put_value(value, key, replacement)

@spec put_value(
  map() | keyword() | struct(),
  atom() | String.t() | non_neg_integer(),
  term()
) ::
  map() | keyword() | struct()

put_value_in(value, path, replacement)

@spec put_value_in(map() | struct(), [atom() | String.t()], term()) ::
  map() | struct()

rawencode(params)

@spec rawencode(map() | keyword()) :: String.t()

rsa(payload, secret, atom)

@spec rsa(binary(), binary(), atom()) :: String.t()

safe_balance(balance)

@spec safe_balance(map()) :: map()

safe_bool2(value, key1, key2)

@spec safe_bool2(map() | keyword() | nil, atom() | String.t(), atom() | String.t()) ::
  boolean() | nil

safe_bool2(value, key1, key2, default)

@spec safe_bool2(
  map() | keyword() | nil,
  atom() | String.t(),
  atom() | String.t(),
  boolean() | nil
) :: boolean() | nil

safe_bool(value, key, default \\ nil)

@spec safe_bool(map() | keyword() | nil, atom() | String.t(), boolean() | nil) ::
  boolean() | nil

safe_bool_n(value, keys)

@spec safe_bool_n(term(), [atom() | String.t()]) :: boolean() | nil

safe_currency(currency_id, currency \\ nil)

@spec safe_currency(String.t() | nil, map() | nil) :: map()

safe_currency_code(currency_id, currency \\ nil)

@spec safe_currency_code(String.t() | nil, map() | nil) :: String.t() | nil

safe_currency_structure(currency)

@spec safe_currency_structure(map()) :: map()

safe_dict2(value, key1, key2, default \\ nil)

@spec safe_dict2(
  term(),
  atom() | String.t() | non_neg_integer(),
  atom() | String.t() | non_neg_integer(),
  map() | nil
) :: map() | nil

safe_dict2(exchange, value, key1, key2, default)

@spec safe_dict2(
  term(),
  term(),
  atom() | String.t() | non_neg_integer(),
  atom() | String.t() | non_neg_integer(),
  map() | nil
) :: map() | nil

safe_dict(value, key, default \\ nil)

@spec safe_dict(term(), atom() | String.t() | non_neg_integer(), map() | nil) ::
  map() | nil

safe_dict(exchange, value, key, default)

@spec safe_dict(term(), term(), atom() | String.t() | non_neg_integer(), map() | nil) ::
  map() | nil

safe_integer2(value, key1, key2, default \\ nil)

@spec safe_integer2(
  map() | keyword() | nil,
  atom() | String.t(),
  atom() | String.t(),
  integer() | nil
) :: integer() | nil

safe_integer(value, key, default \\ nil)

@spec safe_integer(map() | keyword() | nil, atom() | String.t(), integer() | nil) ::
  integer() | nil

safe_integer_in(value, path, default \\ nil)

@spec safe_integer_in(
  term(),
  [atom() | String.t() | non_neg_integer()],
  integer() | nil
) ::
  integer() | nil

safe_integer_n(value, keys)

@spec safe_integer_n(term(), [atom() | String.t()]) :: integer() | nil

safe_integer_omit_zero(value, key)

@spec safe_integer_omit_zero(term(), atom() | String.t()) :: integer() | nil

safe_integer_product(value, key, factor, default \\ nil)

@spec safe_integer_product(
  map() | keyword() | nil,
  atom() | String.t(),
  number(),
  integer() | nil
) :: integer() | nil

safe_integer_product_in(value, path, factor, default \\ nil)

@spec safe_integer_product_in(
  term(),
  [atom() | String.t() | non_neg_integer()],
  number(),
  integer() | nil
) :: integer() | nil

safe_ledger_entry(entry, currency \\ nil)

@spec safe_ledger_entry(map(), map() | nil) :: map()

safe_liquidation(liquidation)

@spec safe_liquidation(map()) :: map()

safe_list2(value, key1, key2, default \\ nil)

@spec safe_list2(term(), atom() | String.t(), atom() | String.t(), list() | nil) ::
  list() | nil

safe_list2(exchange, value, key1, key2, default)

@spec safe_list2(
  term(),
  term(),
  atom() | String.t(),
  atom() | String.t(),
  list() | nil
) :: list() | nil

safe_list(value, key, default \\ nil)

@spec safe_list(term(), atom() | String.t() | non_neg_integer(), list() | nil) ::
  list() | nil

safe_list(exchange, value, key, default)

@spec safe_list(term(), term(), atom() | String.t() | non_neg_integer(), list() | nil) ::
  list() | nil

safe_market(market_id, market, delimiter \\ nil, market_type \\ nil)

@spec safe_market(
  String.t() | nil,
  map() | String.t() | nil,
  map() | nil,
  String.t() | nil
) :: map()

safe_market(exchange, market_id, market, delimiter, market_type)

@spec safe_market(
  map(),
  String.t() | nil,
  map() | String.t() | nil,
  map() | nil,
  String.t() | nil
) :: map() | nil

safe_number2(value, key1, key2)

@spec safe_number2(term(), atom() | String.t(), atom() | String.t()) :: number() | nil

safe_number2(value, key1, key2, default)

@spec safe_number2(term(), atom() | String.t(), atom() | String.t(), term()) ::
  number() | nil

safe_number(value, key)

@spec safe_number(term(), atom() | String.t() | non_neg_integer()) :: number() | nil

safe_number(value, key, default)

@spec safe_number(term(), atom() | String.t() | non_neg_integer(), term()) ::
  number() | nil

safe_number_omit_zero(value, key)

@spec safe_number_omit_zero(term(), atom() | String.t() | non_neg_integer()) ::
  number() | nil

safe_open_interest(open_interest, market)

@spec safe_open_interest(map(), map() | nil) :: map()

safe_order(order, market \\ nil)

@spec safe_order(map(), map() | nil) :: map()

safe_position(exchange, position)

@spec safe_position(map(), map()) :: map()

safe_string2(value, key1, key2, default \\ nil)

@spec safe_string2(
  map() | keyword() | nil,
  atom() | String.t(),
  atom() | String.t(),
  String.t() | nil
) :: String.t() | nil

safe_string(value, key, default \\ nil)

@spec safe_string(map() | keyword() | nil, atom() | String.t(), String.t() | nil) ::
  String.t() | nil

safe_string_lower2(value, key1, key2, default \\ nil)

@spec safe_string_lower2(
  map() | keyword() | nil,
  atom() | String.t(),
  atom() | String.t(),
  String.t() | nil
) :: String.t() | nil

safe_string_lower(value, key, default \\ nil)

@spec safe_string_lower(
  map() | keyword() | nil,
  atom() | String.t(),
  String.t() | nil
) ::
  String.t() | nil

safe_string_n(value, keys)

@spec safe_string_n(term(), [atom() | String.t()]) :: String.t() | nil

safe_string_upper(value, key, default \\ nil)

@spec safe_string_upper(
  map() | keyword() | nil,
  atom() | String.t(),
  String.t() | nil
) ::
  String.t() | nil

safe_symbol(exchange, market_id, market)

safe_symbol(exchange, market_id, market, default)

safe_symbol(exchange, market_id, market, default, market_type)

@spec safe_symbol(
  map(),
  String.t() | nil,
  map() | nil,
  String.t() | nil,
  String.t() | nil
) ::
  String.t() | nil

safe_ticker(ticker, market \\ nil)

@spec safe_ticker(map(), map() | nil) :: map()

safe_timestamp(value, key, default \\ nil)

@spec safe_timestamp(map() | keyword() | nil, atom() | String.t(), integer() | nil) ::
  integer() | nil

safe_trade(trade, market \\ nil)

@spec safe_trade(map(), map() | nil) :: map()

safe_value2(value, key1, key2, default \\ nil)

@spec safe_value2(term(), atom() | String.t(), atom() | String.t(), term()) :: term()

safe_value(value, key, default \\ nil)

@spec safe_value(term(), atom() | String.t() | non_neg_integer(), term()) :: term()

safe_value_in(value, path, default \\ nil)

@spec safe_value_in(term(), [atom() | String.t() | non_neg_integer()], term()) ::
  term()

set_sandbox_mode(exchange, enabled)

@spec set_sandbox_mode(map(), boolean()) :: map()

slice(value, start, stop \\ nil)

@spec slice(String.t() | list() | nil, integer(), integer() | nil) ::
  String.t() | list() | nil

sort_by(values, key, descending \\ false, default \\ nil)

@spec sort_by(list(), atom() | String.t() | non_neg_integer(), boolean(), term()) ::
  list()

sort_by(exchange, values, key, descending, default)

@spec sort_by(
  term(),
  list(),
  atom() | String.t() | non_neg_integer(),
  boolean(),
  term()
) :: list()

status_from_equals(value, expected, ok_status, else_status)

@spec status_from_equals(term(), term(), String.t(), String.t() | nil) ::
  String.t() | nil

string_eq?(left, right)

@spec string_eq?(term(), term()) :: boolean()

string_gt?(left, right)

@spec string_gt?(term(), term()) :: boolean()

string_lt?(left, right)

@spec string_lt?(term(), term()) :: boolean()

string_lte?(left, right)

@spec string_lte?(term(), term()) :: boolean()

string_split(value, separator)

@spec string_split(String.t() | nil, String.t()) :: [String.t()]

subtract_number_strings(left, right)

@spec subtract_number_strings(term(), term()) :: String.t() | nil

sum(exchange, left, right)

@spec sum(term(), number() | nil, number() | nil) :: number() | nil

take_exchange_options(exchange, params)

@spec take_exchange_options(map(), map() | keyword()) :: {map(), map() | keyword()}

throw_broadly_matched_exception(exceptions, key, message)

@spec throw_broadly_matched_exception(map() | nil, String.t() | nil, String.t()) ::
  :ok | no_return()

throw_exactly_matched_exception(exceptions, key, message)

@spec throw_exactly_matched_exception(map() | nil, term(), String.t()) ::
  :ok | no_return()

timeframe(exchange, value)

@spec timeframe(String.t(), String.t()) :: String.t()

timeframes(exchange)

@spec timeframes(term()) :: map()

truthy(value)

@spec truthy(term()) :: boolean()

typeof(value)

@spec typeof(term()) :: String.t()

upcase(value)

@spec upcase(String.t() | nil) :: String.t() | nil

urlencode(params)

@spec urlencode(map() | keyword()) :: String.t()

urlencode_with_array_repeat(params)

@spec urlencode_with_array_repeat(map() | keyword()) :: String.t()

uuid22()

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

yymmdd(timestamp)

@spec yymmdd(integer() | nil) :: String.t() | nil

yymmdd(exchange, timestamp)

@spec yymmdd(term(), integer() | nil) :: String.t() | nil