krakenapi.h

#pragma once 
#include "app.h"
#include "api.h"
#include "krakenconfig.h"
#include "helper.h"


namespace trader {

    namespace KrakenApi {
    
        class AccountBalance :  public Poco::RefCountedObject {
        public:
            
            AccountBalance();
            
            ~AccountBalance();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                typedef double  ResultMap;
                
                typedef std::map<std::string, ResultMap> Result;
                Result  result;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //AccountBalance
        
        class AssetInfo :  public Poco::RefCountedObject {
        public:
            
            AssetInfo();
            
            ~AssetInfo();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultMap {
                    
                    void SetAclass(std::string val)
                    {
                        aclass = val;
                    }
                    
                    bool isSetAclass() {
                        return (aclass != "Empty");
                    }
                    
                    std::string aclass;
                    
                    void SetAltname(std::string val)
                    {
                        altname = val;
                    }
                    
                    bool isSetAltname() {
                        return (altname != "Empty");
                    }
                    
                    std::string altname;
                    
                    void SetDecimals(Poco::Int32 val)
                    {
                        decimals = val;
                    }
                    
                    bool isSetDecimals() {
                        return (decimals != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 decimals;
                    
                    void SetDisplay_decimals(Poco::Int32 val)
                    {
                        display_decimals = val;
                    }
                    
                    bool isSetDisplay_decimals() {
                        return (display_decimals != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 display_decimals;
                    
                    ResultMap()
                    : aclass("Empty")
                    , altname("Empty")
                    , decimals(std::numeric_limits<Poco::Int32>::max())
                    , display_decimals(std::numeric_limits<Poco::Int32>::max())
                    {
                    }
                
                };
                
                typedef std::map<std::string, ResultMap> Result;
                Result  result;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //AssetInfo
        
        class AssetInfoParams :  public Poco::RefCountedObject {
        public:
            
            AssetInfoParams();
            
            ~AssetInfoParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // Asset Class - currency (default)
                void SetAclass(std::string val)
                {
                    aclass = val;
                }
                
                bool isSetAclass() {
                    return (aclass != "Empty");
                }
                
                std::string aclass;
                
                // Comma delimited list of assets to get info on (optional.  default = all for given asset class)
                void SetAsset(std::string val)
                {
                    asset = val;
                }
                
                bool isSetAsset() {
                    return (asset != "Empty");
                }
                
                std::string asset;
                
                // Info to retrieve - all info (default)
                void SetInfo(std::string val)
                {
                    info = val;
                }
                
                bool isSetInfo() {
                    return (info != "Empty");
                }
                
                std::string info;
                
                DataObject()
                : aclass("Empty")
                , asset("Empty")
                , info("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //AssetInfoParams
        
        class AssetPairs :  public Poco::RefCountedObject {
        public:
            
            AssetPairs();
            
            ~AssetPairs();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultMap {
                    
                    // asset class of base component
                    void SetAclass_base(std::string val)
                    {
                        aclass_base = val;
                    }
                    
                    bool isSetAclass_base() {
                        return (aclass_base != "Empty");
                    }
                    
                    std::string aclass_base;
                    
                    // asset class of quote component
                    void SetAclass_quote(std::string val)
                    {
                        aclass_quote = val;
                    }
                    
                    bool isSetAclass_quote() {
                        return (aclass_quote != "Empty");
                    }
                    
                    std::string aclass_quote;
                    
                    // alternate pair name
                    void SetAltname(std::string val)
                    {
                        altname = val;
                    }
                    
                    bool isSetAltname() {
                        return (altname != "Empty");
                    }
                    
                    std::string altname;
                    
                    // asset id of base component
                    void SetBase(std::string val)
                    {
                        base = val;
                    }
                    
                    bool isSetBase() {
                        return (base != "Empty");
                    }
                    
                    std::string base;
                    
                    // volume discount currency
                    void SetFee_volume_currency(std::string val)
                    {
                        fee_volume_currency = val;
                    }
                    
                    bool isSetFee_volume_currency() {
                        return (fee_volume_currency != "Empty");
                    }
                    
                    std::string fee_volume_currency;
                    
                    typedef double  FeesArrayArray;
                    
                    typedef std::vector<FeesArrayArray> FeesArray;
                    typedef std::vector<FeesArray> Fees;
                    Fees    fees;
                    typedef double  Fees_makerArrayArray;
                    
                    typedef std::vector<Fees_makerArrayArray> Fees_makerArray;
                    typedef std::vector<Fees_makerArray> Fees_maker;
                    Fees_maker  fees_maker;
                    typedef double  Leverage_buyArray;
                    
                    typedef std::vector<Leverage_buyArray> Leverage_buy;
                    Leverage_buy    leverage_buy;
                    typedef double  Leverage_sellArray;
                    
                    typedef std::vector<Leverage_sellArray> Leverage_sell;
                    Leverage_sell   leverage_sell;
                    // volume lot size
                    void SetLot(std::string val)
                    {
                        lot = val;
                    }
                    
                    bool isSetLot() {
                        return (lot != "Empty");
                    }
                    
                    std::string lot;
                    
                    // scaling decimal places for volume
                    void SetLot_decimals(Poco::Int32 val)
                    {
                        lot_decimals = val;
                    }
                    
                    bool isSetLot_decimals() {
                        return (lot_decimals != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 lot_decimals;
                    
                    // amount to multiply lot volume by to get currency volume
                    void SetLot_multiplier(Poco::Int32 val)
                    {
                        lot_multiplier = val;
                    }
                    
                    bool isSetLot_multiplier() {
                        return (lot_multiplier != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 lot_multiplier;
                    
                    // margin call level
                    void SetMargin_call(Poco::Int32 val)
                    {
                        margin_call = val;
                    }
                    
                    bool isSetMargin_call() {
                        return (margin_call != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 margin_call;
                    
                    // stop-out/liquidation margin level
                    void SetMargin_stop(Poco::Int32 val)
                    {
                        margin_stop = val;
                    }
                    
                    bool isSetMargin_stop() {
                        return (margin_stop != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 margin_stop;
                    
                    // scaling decimal places for pair
                    void SetPair_decimals(Poco::Int32 val)
                    {
                        pair_decimals = val;
                    }
                    
                    bool isSetPair_decimals() {
                        return (pair_decimals != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 pair_decimals;
                    
                    // asset id of quote component
                    void SetQuote(std::string val)
                    {
                        quote = val;
                    }
                    
                    bool isSetQuote() {
                        return (quote != "Empty");
                    }
                    
                    std::string quote;
                    
                    ResultMap()
                    : aclass_base("Empty")
                    , aclass_quote("Empty")
                    , altname("Empty")
                    , base("Empty")
                    , fee_volume_currency("Empty")
                    , lot("Empty")
                    , lot_decimals(std::numeric_limits<Poco::Int32>::max())
                    , lot_multiplier(std::numeric_limits<Poco::Int32>::max())
                    , margin_call(std::numeric_limits<Poco::Int32>::max())
                    , margin_stop(std::numeric_limits<Poco::Int32>::max())
                    , pair_decimals(std::numeric_limits<Poco::Int32>::max())
                    , quote("Empty")
                    {
                    }
                
                };
                
                typedef std::map<std::string, ResultMap> Result;
                Result  result;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //AssetPairs
        
        class AssetPairsParams :  public Poco::RefCountedObject {
        public:
            
            AssetPairsParams();
            
            ~AssetPairsParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // info to retrieve (optional), info = all info (default), leverage = leverage info, fees = fees schedule, margin = margin info
                void SetInfo(std::string val)
                {
                    info = val;
                }
                
                bool isSetInfo() {
                    return (info != "Empty");
                }
                
                std::string info;
                
                // comma delimited list of asset pairs to get info on (optional.  default = all)
                void SetPair(std::string val)
                {
                    pair = val;
                }
                
                bool isSetPair() {
                    return (pair != "Empty");
                }
                
                std::string pair;
                
                DataObject()
                : info("Empty")
                , pair("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //AssetPairsParams
        
        class ErrorIntrospector :  public Poco::RefCountedObject {
        public:
            
            ErrorIntrospector();
            
            ~ErrorIntrospector();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                typedef std::string ErrorArray;
                
                typedef std::vector<ErrorArray> Error;
                Error   error;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //ErrorIntrospector
        
        class OHLCData :  public Poco::RefCountedObject {
        public:
            
            OHLCData();
            
            ~OHLCData();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                typedef double  ResultMapArrayArray;
                
                typedef std::vector<ResultMapArrayArray> ResultMapArray;
                typedef std::vector<ResultMapArray> ResultMap;
                typedef std::map<std::string, ResultMap> Result;
                Result  result;
                // id to be used as since when polling for new, committed OHLC data
                void SetLast(Poco::Int32 val)
                {
                    last = val;
                }
                
                bool isSetLast() {
                    return (last != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 last;
                
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OHLCData
        
        class OHLCDataParams :  public Poco::RefCountedObject {
        public:
            
            OHLCDataParams();
            
            ~OHLCDataParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // time frame interval in minutes (optional): 1 (default), 5, 15, 30, 60, 240, 1440, 10080, 21600
                void SetInterval (double val)
                {
                    interval  = val;
                }
                
                bool isSetInterval () {
                    return (interval  != std::numeric_limits<double>::max());
                }
                
                double  interval ;
                
                // asset pair to get OHLC data for
                void SetPair(std::string val)
                {
                    pair = val;
                }
                
                bool isSetPair() {
                    return (pair != "Empty");
                }
                
                std::string pair;
                
                // return committed OHLC data since given id (optional.  exclusive)
                void SetSince(double val)
                {
                    since = val;
                }
                
                bool isSetSince() {
                    return (since != std::numeric_limits<double>::max());
                }
                
                double  since;
                
                DataObject()
                : interval (std::numeric_limits<double>::max())
                , pair("Empty")
                , since(std::numeric_limits<double>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OHLCDataParams
        
        class OrderBook :  public Poco::RefCountedObject {
        public:
            
            OrderBook();
            
            ~OrderBook();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultMap {
                    
                    typedef double  AsksArrayArray;
                    
                    typedef std::vector<AsksArrayArray> AsksArray;
                    typedef std::vector<AsksArray> Asks;
                    Asks    asks;
                    typedef double  BidsArrayArray;
                    
                    typedef std::vector<BidsArrayArray> BidsArray;
                    typedef std::vector<BidsArray> Bids;
                    Bids    bids;
                    ResultMap()
                    {
                    }
                
                };
                
                typedef std::map<std::string, ResultMap> Result;
                Result  result;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OrderBook
        
        class OrderBookParams :  public Poco::RefCountedObject {
        public:
            
            OrderBookParams();
            
            ~OrderBookParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // maximum number of asks/bids (optional)
                void SetCount(Poco::Int32 val)
                {
                    count = val;
                }
                
                bool isSetCount() {
                    return (count != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 count;
                
                // asset pair to get OHLC data for
                void SetPair(std::string val)
                {
                    pair = val;
                }
                
                bool isSetPair() {
                    return (pair != "Empty");
                }
                
                std::string pair;
                
                DataObject()
                : count(std::numeric_limits<Poco::Int32>::max())
                , pair("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //OrderBookParams
        
        class RecentSpread :  public Poco::RefCountedObject {
        public:
            
            RecentSpread();
            
            ~RecentSpread();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                typedef double  ResultMapArrayArray;
                
                typedef std::vector<ResultMapArrayArray> ResultMapArray;
                typedef std::vector<ResultMapArray> ResultMap;
                typedef std::map<std::string, ResultMap> Result;
                Result  result;
                // id to be used as since when polling for new spread data
                void SetLast(Poco::Int32 val)
                {
                    last = val;
                }
                
                bool isSetLast() {
                    return (last != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 last;
                
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //RecentSpread
        
        class RecentSpreadParams :  public Poco::RefCountedObject {
        public:
            
            RecentSpreadParams();
            
            ~RecentSpreadParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetPair(std::string val)
                {
                    pair = val;
                }
                
                bool isSetPair() {
                    return (pair != "Empty");
                }
                
                std::string pair;
                
                // return spread data since given id (optional.  inclusive)
                void SetSince(Poco::Int32 val)
                {
                    since = val;
                }
                
                bool isSetSince() {
                    return (since != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 since;
                
                DataObject()
                : pair("Empty")
                , since(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //RecentSpreadParams
        
        class RecentTrades :  public Poco::RefCountedObject {
        public:
            
            RecentTrades();
            
            ~RecentTrades();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                typedef std::string ResultMapArrayArray;
                
                typedef std::vector<ResultMapArrayArray> ResultMapArray;
                typedef std::vector<ResultMapArray> ResultMap;
                typedef std::map<std::string, ResultMap> Result;
                Result  result;
                // id to be used as since when polling for new trade data
                void SetLast(std::string val)
                {
                    last = val;
                }
                
                bool isSetLast() {
                    return (last != "Empty");
                }
                
                std::string last;
                
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //RecentTrades
        
        class RecentTradesParams :  public Poco::RefCountedObject {
        public:
            
            RecentTradesParams();
            
            ~RecentTradesParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // asset pair to get OHLC data for
                void SetPair(std::string val)
                {
                    pair = val;
                }
                
                bool isSetPair() {
                    return (pair != "Empty");
                }
                
                std::string pair;
                
                // return trade data since given id (optional.  exclusive)
                void SetSince(Poco::Int32 val)
                {
                    since = val;
                }
                
                bool isSetSince() {
                    return (since != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 since;
                
                DataObject()
                : pair("Empty")
                , since(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //RecentTradesParams
        
        class ServerTime :  public Poco::RefCountedObject {
        public:
            
            ServerTime();
            
            ~ServerTime();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultObject {
                    
                    void SetRfc1123(std::string val)
                    {
                        rfc1123 = val;
                    }
                    
                    bool isSetRfc1123() {
                        return (rfc1123 != "Empty");
                    }
                    
                    std::string rfc1123;
                    
                    void SetUnixtime(Poco::Int32 val)
                    {
                        unixtime = val;
                    }
                    
                    bool isSetUnixtime() {
                        return (unixtime != std::numeric_limits<Poco::Int32>::max());
                    }
                    
                    Poco::Int32 unixtime;
                    
                    ResultObject()
                    : rfc1123("Empty")
                    , unixtime(std::numeric_limits<Poco::Int32>::max())
                    {
                    }
                
                };
                
                ResultObject    resultObject;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //ServerTime
        
        class StandardOrder :  public Poco::RefCountedObject {
        public:
            
            StandardOrder();
            
            ~StandardOrder();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultObject {
                    
                    struct DescrObject {
                        
                        // conditional close order description (if conditional close set)
                        void SetClose(std::string val)
                        {
                            close = val;
                        }
                        
                        bool isSetClose() {
                            return (close != "Empty");
                        }
                        
                        std::string close;
                        
                        // order description
                        void SetOrder(std::string val)
                        {
                            order = val;
                        }
                        
                        bool isSetOrder() {
                            return (order != "Empty");
                        }
                        
                        std::string order;
                        
                        DescrObject()
                        : close("Empty")
                        , order("Empty")
                        {
                        }
                    
                    };
                    
                    DescrObject descrObject;
                    typedef std::string TxidArray;
                    
                    typedef std::vector<TxidArray> Txid;
                    Txid    txid;
                    ResultObject()
                    {
                    }
                
                };
                
                ResultObject    resultObject;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //StandardOrder
        
        class StandardOrderParams :  public Poco::RefCountedObject {
        public:
            
            StandardOrderParams();
            
            ~StandardOrderParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // expiration time (optional):
                //  0 = no expiration (default)
                //  +<n> = expire <n> seconds from now
                //  <n> = unix timestamp of expiration time
                void SetExpiretm(std::string val)
                {
                    expiretm = val;
                }
                
                bool isSetExpiretm() {
                    return (expiretm != "Empty");
                }
                
                std::string expiretm;
                
                // amount of leverage desired
                //  (optional.  default = none)
                void SetLeverage(Poco::Int32 val)
                {
                    leverage = val;
                }
                
                bool isSetLeverage() {
                    return (leverage != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 leverage;
                
                // comma delimited list of order flags (optional):
                //  viqc = volume in quote currency (not available for leveraged orders)
                //  fcib = prefer fee in base currency
                //  fciq = prefer fee in quote currency
                //  nompp = no market price protection
                //  post = post only order (available when ordertype = limit)
                void SetOflags(std::string val)
                {
                    oflags = val;
                }
                
                bool isSetOflags() {
                    return (oflags != "Empty");
                }
                
                std::string oflags;
                
                // order type:
                //  market
                //  limit (price = limit price)
                //  stop-loss (price = stop loss price)
                //  take-profit (price = take profit price)
                //  stop-loss-profit (price = stop loss price, price2 = take profit price)
                //  stop-loss-profit-limit (price = stop loss price, price2 = take profit price)
                //  stop-loss-limit (price = stop loss trigger price, price2 = triggered limit price)
                //  take-profit-limit (price = take profit trigger price, price2 = triggered limit price)
                //  trailing-stop (price = trailing stop offset)
                //  trailing-stop-limit (price = trailing stop offset, price2 = triggered limit offset)
                //  stop-loss-and-limit (price = stop loss price, price2 = limit price)
                //  settle-position
                void SetOrdertype(std::string val)
                {
                    ordertype = val;
                }
                
                bool isSetOrdertype() {
                    return (ordertype != "Empty");
                }
                
                std::string ordertype;
                
                // asset pair
                void SetPair(std::string val)
                {
                    pair = val;
                }
                
                bool isSetPair() {
                    return (pair != "Empty");
                }
                
                std::string pair;
                
                // price (optional.  dependent upon ordertype)
                void SetPrice(std::string val)
                {
                    price = val;
                }
                
                bool isSetPrice() {
                    return (price != "Empty");
                }
                
                std::string price;
                
                // secondary price
                //  (optional.  dependent upon ordertype)
                void SetPrice2(std::string val)
                {
                    price2 = val;
                }
                
                bool isSetPrice2() {
                    return (price2 != "Empty");
                }
                
                std::string price2;
                
                // scheduled start time (optional):
                //  0 = now (default)
                //  +<n> = schedule start time <n> seconds from now
                //  <n> = unix timestamp of start time
                void SetStarttm(std::string val)
                {
                    starttm = val;
                }
                
                bool isSetStarttm() {
                    return (starttm != "Empty");
                }
                
                std::string starttm;
                
                // type of order (buy/sell)
                void SetType(std::string val)
                {
                    type = val;
                }
                
                bool isSetType() {
                    return (type != "Empty");
                }
                
                std::string type;
                
                // user reference id.  32-bit signed number.  (optional)
                void SetUserref(Poco::Int32 val)
                {
                    userref = val;
                }
                
                bool isSetUserref() {
                    return (userref != std::numeric_limits<Poco::Int32>::max());
                }
                
                Poco::Int32 userref;
                
                // validate inputs only.  do not submit order (optional)
                void SetValidate(bool val)
                {
                    validate = val;
                    validateSet = true;
                }
                
                bool isSetValidate() {
                    return (validateSet != false);
                }
                
                bool    validate;
                bool    validateSet;
                
                // order volume in lots
                void SetVolume(double val)
                {
                    volume = val;
                }
                
                bool isSetVolume() {
                    return (volume != std::numeric_limits<double>::max());
                }
                
                double  volume;
                
                DataObject()
                : expiretm("Empty")
                , leverage(std::numeric_limits<Poco::Int32>::max())
                , oflags("Empty")
                , ordertype("Empty")
                , pair("Empty")
                , price("Empty")
                , price2("Empty")
                , starttm("Empty")
                , type("Empty")
                , userref(std::numeric_limits<Poco::Int32>::max())
                , validate(false)
                , validateSet(false)
                , volume(std::numeric_limits<double>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //StandardOrderParams
        
        class TickerInformation :  public Poco::RefCountedObject {
        public:
            
            TickerInformation();
            
            ~TickerInformation();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultMap {
                    
                    typedef double  AArray;
                    
                    typedef std::vector<AArray> A;
                    A   a;
                    typedef double  BArray;
                    
                    typedef std::vector<BArray> B;
                    B   b;
                    typedef double  CArray;
                    
                    typedef std::vector<CArray> C;
                    C   c;
                    typedef double  HArray;
                    
                    typedef std::vector<HArray> H;
                    H   h;
                    typedef double  LArray;
                    
                    typedef std::vector<LArray> L;
                    L   l;
                    // today's opening price
                    void SetO(double val)
                    {
                        o = val;
                    }
                    
                    bool isSetO() {
                        return (o != std::numeric_limits<double>::max());
                    }
                    
                    double  o;
                    
                    typedef double  PArray;
                    
                    typedef std::vector<PArray> P;
                    P   p;
                    typedef double  TArray;
                    
                    typedef std::vector<TArray> T;
                    T   t;
                    typedef double  VArray;
                    
                    typedef std::vector<VArray> V;
                    V   v;
                    ResultMap()
                    : o(std::numeric_limits<double>::max())
                    {
                    }
                
                };
                
                typedef std::map<std::string, ResultMap> Result;
                Result  result;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //TickerInformation
        
        class TickerInformationParams :  public Poco::RefCountedObject {
        public:
            
            TickerInformationParams();
            
            ~TickerInformationParams();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                // comma delimited list of asset pairs to get info on
                void SetPair(std::string val)
                {
                    pair = val;
                }
                
                bool isSetPair() {
                    return (pair != "Empty");
                }
                
                std::string pair;
                
                DataObject()
                : pair("Empty")
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //TickerInformationParams
        
        class EndPoints {
        public:
            
            EndPoints(Poco::AutoPtr<trader::App> app, Api* api);
            
            ~EndPoints();
            
            
            // Get server time
            Poco::AutoPtr<ServerTime> GetServerTime();
            
            // Returns list of asset names and info
            Poco::AutoPtr<AssetInfo> GetAssetInfo(Poco::AutoPtr<AssetInfoParams> assetInfoParams);
            
            // Get tradable asset pairs
            Poco::AutoPtr<AssetPairs> GetAssetPairs(Poco::AutoPtr<AssetPairsParams> assetPairsParams);
            
            // Get Ticker Information -
            //  Note: Today's prices start at 00:00:00 UTC
            Poco::AutoPtr<TickerInformation> GetTickerInformation(Poco::AutoPtr<TickerInformationParams> tickerInformationParams);
            
            // Get OHLC data -
            //  Note: the last entry in the OHLC array is for the current,
            //  not-yet-committed frame and will always be present,
            //  regardless of the value of "since".
            Poco::AutoPtr<OHLCData> GetOHLCData(Poco::AutoPtr<OHLCDataParams> oHLCDataParams);
            
            // Array of asset names and balance amount
            Poco::AutoPtr<AccountBalance> GetAccountBalance();
            
            // Get Order Book
            Poco::AutoPtr<OrderBook> GetOrderBook(Poco::AutoPtr<OrderBookParams> orderBookParams);
            
            // Get Recent Trades
            Poco::AutoPtr<RecentTrades> GetRecentTrades(Poco::AutoPtr<RecentTradesParams> recentTradesParams);
            
            // Recent Spread Data
            Poco::AutoPtr<RecentSpread> GetRecentSpread(Poco::AutoPtr<RecentSpreadParams> recentSpreadParams);
            
            // Add Standard Order
            Poco::AutoPtr<StandardOrder> AddStandardOrder(Poco::AutoPtr<StandardOrderParams> standardOrderParams);
            
            KrakenConfig    config;
            
            Poco::AutoPtr<trader::App>  _app;
            Api*    _api;
            std::string _uri;
        }; //EndPoints
        
    } //KrakenApi
} //trader