Struct AvailableItem 

pub struct AvailableItem {

    pub available_barriers: Option<Vec<Value>>,
    pub barrier: Option<Value>,
    pub barrier_category: String,
    pub barrier_choices: Option<Vec<Value>>,
    pub barriers: f64,
    pub cancellation_range: Option<Vec<Value>>,
    pub contract_category: String,
    pub contract_category_display: String,
    pub contract_display: Option<String>,
    pub contract_type: String,
    pub default_stake: Option<f64>,
    pub display_number_of_contracts: Option<f64>,
    pub duration_choices: Option<Vec<i64>>,
    pub exchange_name: String,
    pub expired_barriers: Option<Vec<Value>>,
    pub expiry_type: String,
    pub forward_starting_options: Option<Vec<ForwardStartingOptionItem>>,
    pub growth_rate_range: Option<Vec<Value>>,
    pub high_barrier: Option<Value>,
    pub last_digit_range: Option<Vec<Value>>,
    pub low_barrier: Option<Value>,
    pub market: String,
    pub max_contract_duration: String,
    pub max_stake: Option<Value>,
    pub min_contract_duration: String,
    pub min_stake: Option<Value>,
    pub multiplier_range: Option<Vec<Value>>,
    pub payout_choices: Option<Vec<Value>>,
    pub payout_limit: Option<f64>,
    pub sentiment: String,
    pub start_type: String,
    pub submarket: String,
    pub trade_risk_profile_choices: Option<Vec<String>>,
    pub trading_period: Option<Value>,
    pub underlying_symbol: String,
}

Fields

available_barriers: Option<Vec<Value>>

Array of available barriers for a predefined trading period\n

barrier: Option<Value>

Barrier Details.\n

barrier_category: String

Category of barrier.\n

barrier_choices: Option<Vec<Value>>

[Only for Vanilla] Barrier Choices\n

barriers: f64

Number of barriers.\n

cancellation_range: Option<Vec<Value>>

Cancellation range\n

contract_category: String

Category of contract.\n

contract_category_display: String

Category of the contract.\n

contract_display: Option<String>

Display name for the type of contract.\n

contract_type: String

Type of contract.\n

default_stake: Option<f64>

Default stake for the contract\n

display_number_of_contracts: Option<f64>

[Only for Turbos] Its selected payout per point\n

duration_choices: Option<Vec<i64>>

[Only for Snowball] Available contract durations in seconds.\n

exchange_name: String

Name of exchange\n

expired_barriers: Option<Vec<Value>>

Array of barriers already expired\n

expiry_type: String

Expiry Type.\n

forward_starting_options: Option<Vec<ForwardStartingOptionItem>>

Array of returned forward starting options\n

growth_rate_range: Option<Vec<Value>>

Growth rate range.\n

high_barrier: Option<Value>

High barrier Details.\n

last_digit_range: Option<Vec<Value>>

Last digit range\n

low_barrier: Option<Value>

Low barrier Details.\n

market: String

Type of market.\n

max_contract_duration: String

Maximum contract duration\n

max_stake: Option<Value>

[Only for turbos options] Maximum contract stake\n

min_contract_duration: String

Minimum contract duration.\n

min_stake: Option<Value>

[Only for turbos options] Minimum contract stake\n

multiplier_range: Option<Vec<Value>>

Multiplier range.\n

payout_choices: Option<Vec<Value>>

[Only for Turbos] Payout Choices\n

payout_limit: Option<f64>

Maximum payout.\n

sentiment: String

Type of sentiment.\n

start_type: String

Start Type.\n

submarket: String

Type of submarket.\n

trade_risk_profile_choices: Option<Vec<String>>

[Only for Snowball] Available risk profile options.\n

trading_period: Option<Value>

A hash of predefined trading period\n

underlying_symbol: String

Symbol code\n

Trait Implementations

impl Clone for AvailableItem

fn clone(&self) -> AvailableItem

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AvailableItem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AvailableItem

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AvailableItem

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.