declare type Barriers = number[];
declare type ChartTick = any[];
declare type ChartCandle = any[];

declare interface ForwardStartingOption {
    range: any[],
    options: DurationOption[]
}

declare interface DurationOption {
    min: number,
    max: number,
    unit: 't' | 'm' | 'h' | 'd'
}

declare interface Candle {
    open: number,
    high: number,
    low: number,
    close: number,
    epoch?: number,
}

declare type ServerBoolean = 0 | 1;

declare interface Contract {
    barrier_count: number,
    barrier?: number,
    barrier2?: number,
    bid_price: number,
    buy_price: number,
    contract_type: string,
    contract_id: string,
    currency: 'USD' | 'GBP' | 'EUR' | 'AUD',
    current_spot: number,
    current_spot_time: number,
    date_expiry: number,
    date_settlement: number,
    date_start: number,
    display_name: string,
    display_value: string,
    entry_spot?: number,
    entry_tick: number,
    entry_tick_time: number,
    exit_tick?: number,
    exit_tick_time?: number,
    forward_starting_options?: [],
    high_barrier?: number,
    has_corporate_actions: ServerBoolean,
    is_expired: ServerBoolean,
    is_forward_starting: ServerBoolean,
    is_intraday: ServerBoolean,
    is_path_dependent: ServerBoolean,
    is_valid_to_sell: ServerBoolean,
    low_barrier?: number,
    longcode: string,
    purchase_time: number,
    original_high_barrier?: string,
    original_low_barrier?: string,
    original_barrier?: string,
    payout: number,
    sell_price?: number,
    sell_time?: number,
    sell_spot?: number,
    sell_spot_time?: number,
    tick_count?: number,
    transaction_ids: any[],
    underlying: string,
    validation_error?: string
}

declare interface SpreadContract extends Contract {
    amount_per_point: number,
    current_level: number,
    current_value_in_dollar: number,
    current_value_in_point: number,
    entry_level: number,
    exit_level: number,
    stop_loss_level: number,
    stop_profit_level: number,
    stop_type: 'dollar' | 'point',
    stop_profit: number,
    stop_loss: number,
}


declare interface PrettySpreadContract {
    amountPerPoint: number,
    stopType: 'dollar' | 'point',
    stopProfit: number,
    stopLoss: number,
}

declare interface ExtendedContract extends Contract {
    barrierType: number,
    [key: string]: any; // to allow contract[something]
}

declare type ContractType = 'CALL' | 'PUT' | 'HIGHER' | 'LOWER' |
    'DIGITMATCH' | 'DIGITDIFF' | 'DIGITOVER' | 'DIGITUNDER' | 'DIGITEVEN' | 'DIGITODD' |
    'ASIANU' | 'ASIAND' | 'EXPIRYRANGE' | 'EXPIRYMISS' | 'RANGE' | 'UPORDOWN' |
    'ONETOUCH' | 'NOTOUCH' | 'SPREADU' | 'SPREADD';

declare type DurationUnit = 't' | 'm' | 's' | 'h' | 'd';

declare interface Range {
    unit: DurationUnit,
    min: number,
    max: number,
}

declare interface OpenContract {
    contract_id: number,
    transaction_id: number,
    purchase_time: number,
    symbol: string,
    payout: number,
    buy_price: number,
    date_start: number,
    expiry_time: number,
    contract_type: string,
    currency: string,
    longcode: string,
    app_id?: number,
}

declare interface Proposal {
    ask_price: number,
}

declare interface Tick {
    quote: number,
    epoch: number,
}

declare interface AvailableContractDetails {
    amount_per_point?: number,
    available_barriers?: any[],
    barrier_category: string,
    barrier: number,
    barriers: number,
    contract_display: string,
    contract_category: string,
    contract_category_display: string,
    contract_type: string,
    exchange_name: string,
    expiry_type: string,
    expired_barriers?: any[],
    forward_starting_options?: Object[],
    high_barrier?: number,
    last_digit_range?: number,
    low_barrier?: number,
    market: string,
    max_contract_duration: string,
    min_contract_duration: string,
    payout_limit: number,
    submarket: string,
    sentiment: string,
    start_type: string,
    stop_loss?: number,
    stop_profit?: number,
    stop_type?: string,
    trading_period?: any,
    underlying_symbol: string
}