metaapi.cloud-sdk/build/esm/riskManagement/clients/equityTracking/equityTracking.client.js

SDK for MetaApi, a professional cloud forex API which includes MetaTrader REST API and MetaTrader websocket API. Supports both MetaTrader 5 (MT5) and MetaTrader 4 (MT4). CopyFactory copy trading API included. (https://metaapi.cloud)

'use strict';
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
    try {
        var info = gen[key](arg);
        var value = info.value;
    } catch (error) {
        reject(error);
        return;
    }
    if (info.done) {
        resolve(value);
    } else {
        Promise.resolve(value).then(_next, _throw);
    }
}
function _async_to_generator(fn) {
    return function() {
        var self = this, args = arguments;
        return new Promise(function(resolve, reject) {
            var gen = fn.apply(self, args);
            function _next(value) {
                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
            }
            function _throw(err) {
                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
            }
            _next(undefined);
        });
    };
}
import TrackerEventListenerManager from './trackerEventListenerManager';
import PeriodStatisticsStreamManager from './periodStatisticsStreamManager';
import EquityChartStreamManager from './equityChartStreamManager';
import EquityBalanceStreamManager from './equityBalanceStreamManager';
import moment from 'moment';
let EquityTrackingClient = class EquityTrackingClient {
    /**
   * Tracker configuration update
   * @typedef {Object} TrackerUpdate
   * @property {String} name unique tracker name
   */ /**
   * Period length to track profit and drawdown for
   * @typedef {'day' | 'date' | 'week' | 'week-to-date' | 'month' | 'month-to-date' | 'quarter' | 'quarter-to-date' |
   * 'year' | 'year-to-date' | 'lifetime'} Period
   */ /**
   * New tracker configuration
   * @typedef {TrackerUpdate} NewTracker
   * @property {String} [startBrokerTime] time to start tracking from in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format
   * @property {String} [endBrokerTime] time to end tracking at in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format
   * @property {Period} period period to track profit and drawdown for
   * @property {Number} [relativeDrawdownThreshold] relative drawdown threshold after which tracker event is generated,
   * a fraction of 1
   * @property {Number} [absoluteDrawdownThreshold] absolute drawdown threshold after which tracker event is generated,
   * should be greater than 0
   * @property {Number} [relativeProfitThreshold] relative profit threshold after which tracker event is generated,
   * a fraction of 1
   * @property {Number} [absoluteProfitThreshold] absolute profit threshold after which tracker event is generated,
   * should be greater than 0
   */ /**
   * Tracker id
   * @typedef {Object} TrackerId
   * @property {String} id unique tracker id
   */ /**
   * Creates a profit/drawdown tracker. See
   * https://metaapi.cloud/docs/risk-management/restApi/api/createTracker/
   * @param {String} accountId id of the MetaApi account
   * @param {NewTracker} tracker profit/drawdown tracker
   * @return {Promise<TrackerId>} promise resolving with profit/drawdown tracker id
   */ createTracker(accountId, tracker) {
        return this._domainClient.requestApi({
            url: `/users/current/accounts/${accountId}/trackers`,
            headers: {
                'auth-token': this._domainClient.token,
                'api-version': '1'
            },
            method: 'POST',
            data: tracker
        });
    }
    /**
   * Tracker configuration
   * @typedef {NewTracker} Tracker
   * @property {String} _id unique tracker id
   */ /**
   * Returns trackers defined for an account. See
   * https://metaapi.cloud/docs/risk-management/restApi/api/getTrackers/
   * @param {String} accountId id of the MetaApi account
   * @return {Promise<Tracker[]>} promise resolving with trackers
   */ getTrackers(accountId) {
        return this._domainClient.requestApi({
            url: `/users/current/accounts/${accountId}/trackers`,
            headers: {
                'auth-token': this._domainClient.token,
                'api-version': '1'
            },
            method: 'GET'
        });
    }
    /**
   * Returns profit/drawdown tracker by account and id. See
   * https://metaapi.cloud/docs/risk-management/restApi/api/getTracker/
   * @param {string} accountId id of the MetaApi account 
   * @param {string} id tracker id 
   * @returns {Promise<Tracker>} promise resolving with profit/drawdown tracker found
   */ getTracker(accountId, id) {
        return this._domainClient.requestApi({
            url: `/users/current/accounts/${accountId}/trackers/${id}`,
            headers: {
                'auth-token': this._domainClient.token,
                'api-version': '1'
            },
            method: 'GET'
        });
    }
    /**
   * Returns profit/drawdown tracker by account and name
   * @param {string} accountId id of the MetaApi account 
   * @param {string} name tracker name 
   * @returns {Promise<Tracker>} promise resolving with profit/drawdown tracker found
   */ getTrackerByName(accountId, name) {
        return this._domainClient.requestApi({
            url: `/users/current/accounts/${accountId}/trackers/name/${encodeURIComponent(name)}`,
            headers: {
                'auth-token': this._domainClient.token,
                'api-version': '1'
            },
            method: 'GET'
        });
    }
    /**
   * Updates profit/drawdown tracker. See
   * https://metaapi.cloud/docs/risk-management/restApi/api/updateTracker/
   * @param {String} accountId id of the MetaApi account
   * @param {String} id id of the tracker
   * @param {TrackerUpdate} update tracker update
   * @return {Promise} promise resolving when profit/drawdown tracker updated
   */ updateTracker(accountId, id, update) {
        return this._domainClient.requestApi({
            url: `/users/current/accounts/${accountId}/trackers/${id}`,
            method: 'PUT',
            data: update
        });
    }
    /**
   * Removes profit/drawdown tracker. See
   * https://metaapi.cloud/docs/risk-management/restApi/api/removeTracker/
   * @param {String} accountId id of the MetaApi account
   * @param {String} id id of the tracker
   * @return {Promise} promise resolving when profit/drawdown tracker removed
   */ deleteTracker(accountId, id) {
        return this._domainClient.requestApi({
            url: `/users/current/accounts/${accountId}/trackers/${id}`,
            method: 'DELETE'
        });
    }
    /**
   * Type of the exceeded threshold
   * @typedef {'profit' | 'drawdown'} ExceededThresholdType
   */ /**
   * Profit/drawdown threshold exceeded event model
   * @typedef {Object} TrackerEvent
   * @property {Number} sequenceNumber event unique sequence number
   * @property {String} accountId MetaApi account id
   * @property {String} trackerId profit/drawdown tracker id
   * @property {String} startBrokerTime profit/drawdown tracking period start time in broker timezone,
   * in YYYY-MM-DD HH:mm:ss.SSS format
   * @property {String} [endBrokerTime] profit/drawdown tracking period end time in broker timezone,
   * in YYYY-MM-DD HH:mm:ss.SSS format
   * @property {Period} period profit/drawdown tracking period
   * @property {String} brokerTime profit/drawdown threshold exceeded event time in broker timezone,
   * in YYY-MM-DD HH:mm:ss.SSS format
   * @property {Number} absoluteDrawdown absolute drawdown value which was observed when the profit or drawdown
   * threshold was exceeded
   * @property {Number} relativeDrawdown relative drawdown value which was observed when the profit or drawdown
   * threshold was exceeded
   * @property {Number} absoluteProfit absolute profit value which was observed when the profit or drawdown
   * threshold was exceeded
   * @property {Number} relativeProfit relative profit value which was observed when the profit or drawdown
   * threshold was exceeded
   * @property {ExceededThresholdType} exceededThresholdType type of the exceeded threshold
   */ /**
   * Returns tracker events by broker time range. See
   * https://metaapi.cloud/docs/risk-management/restApi/api/getTrackerEvents/
   * @param {String} [startBrokerTime] value of the event time in broker timezone to start loading data from, inclusive,
   * in 'YYYY-MM-DD HH:mm:ss.SSS format
   * @param {String} [endBrokerTime] value of the event time in broker timezone to end loading data at, inclusive,
   * in 'YYYY-MM-DD HH:mm:ss.SSS format
   * @param {String} [accountId] id of the MetaApi account
   * @param {String} [trackerId] id of the tracker
   * @param {Number} [limit] pagination limit, default is 1000
   * @return {Promise<TrackerEvent[]>} promise resolving with tracker events
   */ getTrackerEvents(startBrokerTime, endBrokerTime, accountId, trackerId, limit) {
        return this._domainClient.requestApi({
            url: '/users/current/tracker-events/by-broker-time',
            params: {
                startBrokerTime,
                endBrokerTime,
                accountId,
                trackerId,
                limit
            },
            method: 'GET'
        });
    }
    /**
   * Adds a tracker event listener and creates a job to make requests
   * @param {TrackerEventListener} listener tracker event listener
   * @param {String} [accountId] account id
   * @param {String} [trackerId] tracker id
   * @param {Number} [sequenceNumber] sequence number
   * @return {String} listener id
   */ addTrackerEventListener(listener, accountId, trackerId, sequenceNumber) {
        return this._trackerEventListenerManager.addTrackerEventListener(listener, accountId, trackerId, sequenceNumber);
    }
    /**
   * Removes tracker event listener and cancels the event stream
   * @param {String} listenerId tracker event listener id
   */ removeTrackerEventListener(listenerId) {
        this._trackerEventListenerManager.removeTrackerEventListener(listenerId);
    }
    /**
   * Period statistics
   * @typedef {Object} PeriodStatistics
   * @property {String} startBrokerTime period start time in broker timezone, in YYYY-MM-DD HH:mm:ss format
   * @property {String} [endBrokerTime] period end time in broker timezone, in YYYY-MM-DD HH:mm:ss format
   * @property {Period} period period length
   * @property {Number} initialBalance balance at period start time
   * @property {String} [maxDrawdownTime] time max drawdown was observed at in broker timezone,
   * in YYYY-MM-DD HH:mm:ss format
   * @property {Number} [maxAbsoluteDrawdown] the value of maximum absolute drawdown observed
   * @property {Number} [maxRelativeDrawdown] the value of maximum relative drawdown observed
   * @property {String} [maxProfitTime] time max profit was observed at in broker timezone,
   * in YYYY-MM-DD HH:mm:ss format
   * @property {Number} [maxAbsoluteProfit] the value of maximum absolute profit observed
   * @property {Number} [maxRelativeProfit] the value of maximum relative profit observed
   * @property {Boolean} thresholdExceeded the flag indicating that max allowed total drawdown was exceeded
   * @property {ExceededThresholdType} exceededThresholdType type of the exceeded threshold
   * @property {Number} [balanceAdjustment] balance adjustment applied to equity for tracking drawdown/profit
   * @property {Number} [tradeDayCount] count of days when trades were performed during the period
   */ /**
   * Returns account profit and drawdown tracking statistics by tracker id. See
   * https://metaapi.cloud/docs/risk-management/restApi/api/getTrackingStats/
   * @param {String} accountId id of MetaAPI account
   * @param {String} trackerId id of the tracker
   * @param {String} [startTime] time to start loading stats from, default is current time. Note that stats is loaded in
   * backwards direction
   * @param {Number} [limit] number of records to load, default is 1
   * @param {Boolean} [realTime] if true, real-time data will be requested
   * @return {Promise<PeriodStatistics[]>} promise resolving with profit and drawdown statistics
   */ getTrackingStatistics(accountId, trackerId, startTime, limit, realTime = false) {
        return this._domainClient.requestApi({
            url: `/users/current/accounts/${accountId}/trackers/${trackerId}/statistics`,
            headers: {
                'auth-token': this._domainClient.token,
                'api-version': '1'
            },
            params: {
                startTime,
                limit,
                realTime
            },
            method: 'GET'
        });
    }
    /**
   * Adds a period statistics event listener
   * @param {PeriodStatisticsListener} listener period statistics event listener
   * @param {String} accountId account id
   * @param {String} trackerId tracker id
   * @returns {Promise<String>} listener id
   */ addPeriodStatisticsListener(listener, accountId, trackerId) {
        return this._periodStatisticsStreamManager.addPeriodStatisticsListener(listener, accountId, trackerId);
    }
    /**
   * Removes period statistics event listener by id
   * @param {String} listenerId listener id 
   */ removePeriodStatisticsListener(listenerId) {
        this._periodStatisticsStreamManager.removePeriodStatisticsListener(listenerId);
    }
    /**
   * Equity chart item
   * @typedef {Object} EquityChartItem
   * @property {String} startBrokerTime start time of a chart item as per broker timezone, in YYYY-MM-DD HH:mm:ss format
   * @property {String} endBrokerTime end time of a chart item as per broker timezone, in YYYY-MM-DD HH:mm:ss format
   * @property {Number} averageBalance average balance value during the period
   * @property {Number} minBalance minimum balance value during the period
   * @property {Number} maxBalance maximum balance value during the period
   * @property {Number} averageEquity average equity value during the period
   * @property {Number} minEquity minimum equity value during the period
   * @property {Number} maxEquity maximum equity value during the period
   * @property {Number} startBalance starting balance value observed during the period
   * @property {Number} startEquity starting equity value observed during the period
   * @property {Number} lastBalance last balance value observed during the period
   * @property {Number} lastEquity last equity value observed during the period
   */ /**
   * Returns equity chart by account id. See
   * https://metaapi.cloud/docs/risk-management/restApi/api/getEquityChart/
   * @param {String} accountId metaApi account id
   * @param {String} [startTime] starting broker time in YYYY-MM-DD HH:mm:ss format
   * @param {String} [endTime] ending broker time in YYYY-MM-DD HH:mm:ss format
   * @param {Boolean} [realTime] if true, real-time data will be requested
   * @param {Boolean} [fillSkips] if true, skipped records will be automatically filled based on existing ones
   * @return {Promise<EquityChartItem[]>} promise resolving with equity chart
   */ getEquityChart(accountId, startTime, endTime, realTime = false, fillSkips = false) {
        var _this = this;
        return _async_to_generator(function*() {
            const records = yield _this._domainClient.requestApi({
                url: `/users/current/accounts/${accountId}/equity-chart`,
                headers: {
                    'auth-token': _this._domainClient.token,
                    'api-version': '1'
                },
                params: {
                    startTime,
                    endTime,
                    realTime
                },
                method: 'GET'
            });
            if (fillSkips) {
                let i = 0;
                while(i < records.length - 1){
                    const timeDiff = new Date(records[i + 1].startBrokerTime).getTime() - new Date(records[i].startBrokerTime).getTime();
                    if (timeDiff > 60 * 60 * 1000 && records[i].lastBalance !== undefined) {
                        const recordCopy = JSON.parse(JSON.stringify(records[i]));
                        recordCopy.minEquity = recordCopy.lastEquity;
                        recordCopy.maxEquity = recordCopy.lastEquity;
                        recordCopy.averageEquity = recordCopy.lastEquity;
                        recordCopy.minBalance = recordCopy.lastBalance;
                        recordCopy.maxBalance = recordCopy.lastBalance;
                        recordCopy.averageBalance = recordCopy.lastBalance;
                        const startBrokerTime = new Date(recordCopy.startBrokerTime);
                        startBrokerTime.setUTCHours(startBrokerTime.getUTCHours() + 1);
                        startBrokerTime.setUTCMinutes(0);
                        startBrokerTime.setUTCSeconds(0);
                        startBrokerTime.setUTCMilliseconds(0);
                        recordCopy.startBrokerTime = moment(startBrokerTime).format('YYYY-MM-DD HH:mm:ss.SSS');
                        startBrokerTime.setUTCHours(startBrokerTime.getUTCHours() + 1);
                        startBrokerTime.setUTCMilliseconds(-1);
                        recordCopy.endBrokerTime = moment(startBrokerTime).format('YYYY-MM-DD HH:mm:ss.SSS');
                        recordCopy.brokerTime = recordCopy.endBrokerTime;
                        records.splice(i + 1, 0, recordCopy);
                    }
                    i++;
                }
            }
            return records;
        })();
    }
    /**
   * Adds an equity chart event listener
   * @param {EquityChartListener} listener equity chart event listener
   * @param {String} accountId account id
   * @param {Date} [startTime] date to start tracking from
   * @returns {Promise<string>} listener id
   */ addEquityChartListener(listener, accountId, startTime) {
        return this._equityChartStreamManager.addEquityChartListener(listener, accountId, startTime);
    }
    /**
   * Removes equity chart event listener by id
   * @param {String} listenerId equity chart listener id 
   */ removeEquityChartListener(listenerId) {
        this._equityChartStreamManager.removeEquityChartListener(listenerId);
    }
    /**
   * Adds an equity balance event listener
   * @param {EquityBalanceListener} listener equity balance event listener
   * @param {string} accountId account id
   * @returns {Promise<string>} listener id
   */ addEquityBalanceListener(listener, accountId) {
        return this._equityBalanceStreamManager.addEquityBalanceListener(listener, accountId);
    }
    /**
   * Removes equity balance event listener by id
   * @param {string} listenerId equity balance listener id 
   */ removeEquityBalanceListener(listenerId) {
        this._equityBalanceStreamManager.removeEquityBalanceListener(listenerId);
    }
    /**
   * Constructs RiskManagement equity tracking API client instance
   * @param {DomainClient} domainClient domain client
   * @param {MetaApi} metaApi metaApi SDK instance
   */ constructor(domainClient, metaApi){
        this._domainClient = domainClient;
        this._trackerEventListenerManager = new TrackerEventListenerManager(domainClient);
        this._equityBalanceStreamManager = new EquityBalanceStreamManager(domainClient, metaApi);
        this._periodStatisticsStreamManager = new PeriodStatisticsStreamManager(domainClient, this, metaApi);
        this._equityChartStreamManager = new EquityChartStreamManager(domainClient, this, metaApi);
    }
};
/**
 * metaapi.cloud RiskManagement equity tracking API client (see https://metaapi.cloud/docs/risk-management/)
 */ export { EquityTrackingClient as default };

//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport TrackerEventListenerManager from './trackerEventListenerManager';\nimport PeriodStatisticsStreamManager from './periodStatisticsStreamManager';\nimport EquityChartStreamManager from './equityChartStreamManager';\nimport EquityBalanceStreamManager from './equityBalanceStreamManager';\nimport moment from 'moment';\n\n/**\n * metaapi.cloud RiskManagement equity tracking API client (see https://metaapi.cloud/docs/risk-management/)\n */\nexport default class EquityTrackingClient {\n\n  /**\n   * Constructs RiskManagement equity tracking API client instance\n   * @param {DomainClient} domainClient domain client\n   * @param {MetaApi} metaApi metaApi SDK instance\n   */\n  constructor(domainClient, metaApi) {\n    this._domainClient = domainClient;\n    this._trackerEventListenerManager = new TrackerEventListenerManager(domainClient);\n    this._equityBalanceStreamManager = new EquityBalanceStreamManager(domainClient, metaApi);\n    this._periodStatisticsStreamManager = new PeriodStatisticsStreamManager(domainClient, this, metaApi);\n    this._equityChartStreamManager = new EquityChartStreamManager(domainClient, this, metaApi); \n  }\n\n  /**\n   * Tracker configuration update\n   * @typedef {Object} TrackerUpdate\n   * @property {String} name unique tracker name\n   */\n\n  /**\n   * Period length to track profit and drawdown for\n   * @typedef {'day' | 'date' | 'week' | 'week-to-date' | 'month' | 'month-to-date' | 'quarter' | 'quarter-to-date' |\n   * 'year' | 'year-to-date' | 'lifetime'} Period\n   */\n\n  /**\n   * New tracker configuration\n   * @typedef {TrackerUpdate} NewTracker\n   * @property {String} [startBrokerTime] time to start tracking from in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format\n   * @property {String} [endBrokerTime] time to end tracking at in broker timezone, YYYY-MM-DD HH:mm:ss.SSS format\n   * @property {Period} period period to track profit and drawdown for\n   * @property {Number} [relativeDrawdownThreshold] relative drawdown threshold after which tracker event is generated,\n   * a fraction of 1\n   * @property {Number} [absoluteDrawdownThreshold] absolute drawdown threshold after which tracker event is generated,\n   * should be greater than 0\n   * @property {Number} [relativeProfitThreshold] relative profit threshold after which tracker event is generated,\n   * a fraction of 1\n   * @property {Number} [absoluteProfitThreshold] absolute profit threshold after which tracker event is generated,\n   * should be greater than 0\n   */\n\n  /**\n   * Tracker id\n   * @typedef {Object} TrackerId\n   * @property {String} id unique tracker id\n   */\n\n  /**\n   * Creates a profit/drawdown tracker. See\n   * https://metaapi.cloud/docs/risk-management/restApi/api/createTracker/\n   * @param {String} accountId id of the MetaApi account\n   * @param {NewTracker} tracker profit/drawdown tracker\n   * @return {Promise<TrackerId>} promise resolving with profit/drawdown tracker id\n   */\n  createTracker(accountId, tracker) {\n    return this._domainClient.requestApi({\n      url: `/users/current/accounts/${accountId}/trackers`,\n      headers: {'auth-token': this._domainClient.token, 'api-version': '1'},\n      method: 'POST',\n      data: tracker\n    });\n  }\n\n  /**\n   * Tracker configuration\n   * @typedef {NewTracker} Tracker\n   * @property {String} _id unique tracker id\n   */\n\n  /**\n   * Returns trackers defined for an account. See\n   * https://metaapi.cloud/docs/risk-management/restApi/api/getTrackers/\n   * @param {String} accountId id of the MetaApi account\n   * @return {Promise<Tracker[]>} promise resolving with trackers\n   */\n  getTrackers(accountId) {\n    return this._domainClient.requestApi({\n      url: `/users/current/accounts/${accountId}/trackers`,\n      headers: {'auth-token': this._domainClient.token, 'api-version': '1'},\n      method: 'GET'\n    });\n  }\n\n  /**\n   * Returns profit/drawdown tracker by account and id. See\n   * https://metaapi.cloud/docs/risk-management/restApi/api/getTracker/\n   * @param {string} accountId id of the MetaApi account \n   * @param {string} id tracker id \n   * @returns {Promise<Tracker>} promise resolving with profit/drawdown tracker found\n   */\n  getTracker(accountId, id) {\n    return this._domainClient.requestApi({\n      url: `/users/current/accounts/${accountId}/trackers/${id}`,\n      headers: {'auth-token': this._domainClient.token, 'api-version': '1'},\n      method: 'GET'\n    });\n  }\n\n  /**\n   * Returns profit/drawdown tracker by account and name\n   * @param {string} accountId id of the MetaApi account \n   * @param {string} name tracker name \n   * @returns {Promise<Tracker>} promise resolving with profit/drawdown tracker found\n   */\n  getTrackerByName(accountId, name) {\n    return this._domainClient.requestApi({\n      url: `/users/current/accounts/${accountId}/trackers/name/${encodeURIComponent(name)}`,\n      headers: {'auth-token': this._domainClient.token, 'api-version': '1'},\n      method: 'GET'\n    });\n  }\n\n  /**\n   * Updates profit/drawdown tracker. See\n   * https://metaapi.cloud/docs/risk-management/restApi/api/updateTracker/\n   * @param {String} accountId id of the MetaApi account\n   * @param {String} id id of the tracker\n   * @param {TrackerUpdate} update tracker update\n   * @return {Promise} promise resolving when profit/drawdown tracker updated\n   */\n  updateTracker(accountId, id, update) {\n    return this._domainClient.requestApi({\n      url: `/users/current/accounts/${accountId}/trackers/${id}`,\n      method: 'PUT',\n      data: update\n    });\n  }\n\n  /**\n   * Removes profit/drawdown tracker. See\n   * https://metaapi.cloud/docs/risk-management/restApi/api/removeTracker/\n   * @param {String} accountId id of the MetaApi account\n   * @param {String} id id of the tracker\n   * @return {Promise} promise resolving when profit/drawdown tracker removed\n   */\n  deleteTracker(accountId, id) {\n    return this._domainClient.requestApi({\n      url: `/users/current/accounts/${accountId}/trackers/${id}`,\n      method: 'DELETE'\n    });\n  }\n\n  /**\n   * Type of the exceeded threshold\n   * @typedef {'profit' | 'drawdown'} ExceededThresholdType\n   */\n\n  /**\n   * Profit/drawdown threshold exceeded event model\n   * @typedef {Object} TrackerEvent\n   * @property {Number} sequenceNumber event unique sequence number\n   * @property {String} accountId MetaApi account id\n   * @property {String} trackerId profit/drawdown tracker id\n   * @property {String} startBrokerTime profit/drawdown tracking period start time in broker timezone,\n   * in YYYY-MM-DD HH:mm:ss.SSS format\n   * @property {String} [endBrokerTime] profit/drawdown tracking period end time in broker timezone,\n   * in YYYY-MM-DD HH:mm:ss.SSS format\n   * @property {Period} period profit/drawdown tracking period\n   * @property {String} brokerTime profit/drawdown threshold exceeded event time in broker timezone,\n   * in YYY-MM-DD HH:mm:ss.SSS format\n   * @property {Number} absoluteDrawdown absolute drawdown value which was observed when the profit or drawdown\n   * threshold was exceeded\n   * @property {Number} relativeDrawdown relative drawdown value which was observed when the profit or drawdown\n   * threshold was exceeded\n   * @property {Number} absoluteProfit absolute profit value which was observed when the profit or drawdown\n   * threshold was exceeded\n   * @property {Number} relativeProfit relative profit value which was observed when the profit or drawdown\n   * threshold was exceeded\n   * @property {ExceededThresholdType} exceededThresholdType type of the exceeded threshold\n   */\n\n  /**\n   * Returns tracker events by broker time range. See\n   * https://metaapi.cloud/docs/risk-management/restApi/api/getTrackerEvents/\n   * @param {String} [startBrokerTime] value of the event time in broker timezone to start loading data from, inclusive,\n   * in 'YYYY-MM-DD HH:mm:ss.SSS format\n   * @param {String} [endBrokerTime] value of the event time in broker timezone to end loading data at, inclusive,\n   * in 'YYYY-MM-DD HH:mm:ss.SSS format\n   * @param {String} [accountId] id of the MetaApi account\n   * @param {String} [trackerId] id of the tracker\n   * @param {Number} [limit] pagination limit, default is 1000\n   * @return {Promise<TrackerEvent[]>} promise resolving with tracker events\n   */\n  getTrackerEvents(startBrokerTime, endBrokerTime, accountId, trackerId, limit) {\n    return this._domainClient.requestApi({\n      url: '/users/current/tracker-events/by-broker-time',\n      params: {startBrokerTime, endBrokerTime, accountId, trackerId, limit},\n      method: 'GET'\n    });\n  }\n\n  /**\n   * Adds a tracker event listener and creates a job to make requests\n   * @param {TrackerEventListener} listener tracker event listener\n   * @param {String} [accountId] account id\n   * @param {String} [trackerId] tracker id\n   * @param {Number} [sequenceNumber] sequence number\n   * @return {String} listener id\n   */\n  addTrackerEventListener(listener, accountId, trackerId, sequenceNumber) {\n    return this._trackerEventListenerManager.addTrackerEventListener(listener, accountId, trackerId, sequenceNumber);\n  }\n\n  /**\n   * Removes tracker event listener and cancels the event stream\n   * @param {String} listenerId tracker event listener id\n   */\n  removeTrackerEventListener(listenerId) {\n    this._trackerEventListenerManager.removeTrackerEventListener(listenerId);\n  }\n\n  /**\n   * Period statistics\n   * @typedef {Object} PeriodStatistics\n   * @property {String} startBrokerTime period start time in broker timezone, in YYYY-MM-DD HH:mm:ss format\n   * @property {String} [endBrokerTime] period end time in broker timezone, in YYYY-MM-DD HH:mm:ss format\n   * @property {Period} period period length\n   * @property {Number} initialBalance balance at period start time\n   * @property {String} [maxDrawdownTime] time max drawdown was observed at in broker timezone,\n   * in YYYY-MM-DD HH:mm:ss format\n   * @property {Number} [maxAbsoluteDrawdown] the value of maximum absolute drawdown observed\n   * @property {Number} [maxRelativeDrawdown] the value of maximum relative drawdown observed\n   * @property {String} [maxProfitTime] time max profit was observed at in broker timezone,\n   * in YYYY-MM-DD HH:mm:ss format\n   * @property {Number} [maxAbsoluteProfit] the value of maximum absolute profit observed\n   * @property {Number} [maxRelativeProfit] the value of maximum relative profit observed\n   * @property {Boolean} thresholdExceeded the flag indicating that max allowed total drawdown was exceeded\n   * @property {ExceededThresholdType} exceededThresholdType type of the exceeded threshold\n   * @property {Number} [balanceAdjustment] balance adjustment applied to equity for tracking drawdown/profit\n   * @property {Number} [tradeDayCount] count of days when trades were performed during the period\n   */\n\n  /**\n   * Returns account profit and drawdown tracking statistics by tracker id. See\n   * https://metaapi.cloud/docs/risk-management/restApi/api/getTrackingStats/\n   * @param {String} accountId id of MetaAPI account\n   * @param {String} trackerId id of the tracker\n   * @param {String} [startTime] time to start loading stats from, default is current time. Note that stats is loaded in\n   * backwards direction\n   * @param {Number} [limit] number of records to load, default is 1\n   * @param {Boolean} [realTime] if true, real-time data will be requested\n   * @return {Promise<PeriodStatistics[]>} promise resolving with profit and drawdown statistics\n   */\n  getTrackingStatistics(accountId, trackerId, startTime, limit, realTime = false) {\n    return this._domainClient.requestApi({\n      url: `/users/current/accounts/${accountId}/trackers/${trackerId}/statistics`,\n      headers: {'auth-token': this._domainClient.token, 'api-version': '1'},\n      params: {startTime, limit, realTime},\n      method: 'GET'\n    });\n  }\n\n  /**\n   * Adds a period statistics event listener\n   * @param {PeriodStatisticsListener} listener period statistics event listener\n   * @param {String} accountId account id\n   * @param {String} trackerId tracker id\n   * @returns {Promise<String>} listener id\n   */\n  addPeriodStatisticsListener(listener, accountId, trackerId) {\n    return this._periodStatisticsStreamManager.addPeriodStatisticsListener(listener, accountId, trackerId);\n  }\n\n  /**\n   * Removes period statistics event listener by id\n   * @param {String} listenerId listener id \n   */\n  removePeriodStatisticsListener(listenerId) {\n    this._periodStatisticsStreamManager.removePeriodStatisticsListener(listenerId);\n  }\n\n  /**\n   * Equity chart item\n   * @typedef {Object} EquityChartItem\n   * @property {String} startBrokerTime start time of a chart item as per broker timezone, in YYYY-MM-DD HH:mm:ss format\n   * @property {String} endBrokerTime end time of a chart item as per broker timezone, in YYYY-MM-DD HH:mm:ss format\n   * @property {Number} averageBalance average balance value during the period\n   * @property {Number} minBalance minimum balance value during the period\n   * @property {Number} maxBalance maximum balance value during the period\n   * @property {Number} averageEquity average equity value during the period\n   * @property {Number} minEquity minimum equity value during the period\n   * @property {Number} maxEquity maximum equity value during the period\n   * @property {Number} startBalance starting balance value observed during the period\n   * @property {Number} startEquity starting equity value observed during the period\n   * @property {Number} lastBalance last balance value observed during the period\n   * @property {Number} lastEquity last equity value observed during the period\n   */\n\n  /**\n   * Returns equity chart by account id. See\n   * https://metaapi.cloud/docs/risk-management/restApi/api/getEquityChart/\n   * @param {String} accountId metaApi account id\n   * @param {String} [startTime] starting broker time in YYYY-MM-DD HH:mm:ss format\n   * @param {String} [endTime] ending broker time in YYYY-MM-DD HH:mm:ss format\n   * @param {Boolean} [realTime] if true, real-time data will be requested\n   * @param {Boolean} [fillSkips] if true, skipped records will be automatically filled based on existing ones\n   * @return {Promise<EquityChartItem[]>} promise resolving with equity chart\n   */\n  async getEquityChart(accountId, startTime, endTime, realTime = false, fillSkips = false) {\n    const records = await this._domainClient.requestApi({\n      url: `/users/current/accounts/${accountId}/equity-chart`,\n      headers: {'auth-token': this._domainClient.token, 'api-version': '1'},\n      params: {startTime, endTime, realTime},\n      method: 'GET'\n    });\n    if(fillSkips){\n      let i = 0;\n      while(i < records.length - 1) {\n        const timeDiff = new Date(records[i + 1].startBrokerTime).getTime() - \n        new Date(records[i].startBrokerTime).getTime();\n        \n        if(timeDiff > 60 * 60 * 1000 && records[i].lastBalance !== undefined) {\n          const recordCopy = JSON.parse(JSON.stringify(records[i]));\n          recordCopy.minEquity = recordCopy.lastEquity;\n          recordCopy.maxEquity = recordCopy.lastEquity;\n          recordCopy.averageEquity = recordCopy.lastEquity;\n          recordCopy.minBalance = recordCopy.lastBalance;\n          recordCopy.maxBalance = recordCopy.lastBalance;\n          recordCopy.averageBalance = recordCopy.lastBalance;\n          const startBrokerTime = new Date(recordCopy.startBrokerTime);\n          startBrokerTime.setUTCHours(startBrokerTime.getUTCHours() + 1);\n          startBrokerTime.setUTCMinutes(0);\n          startBrokerTime.setUTCSeconds(0);\n          startBrokerTime.setUTCMilliseconds(0);\n          recordCopy.startBrokerTime = moment(startBrokerTime).format('YYYY-MM-DD HH:mm:ss.SSS');\n          startBrokerTime.setUTCHours(startBrokerTime.getUTCHours() + 1);\n          startBrokerTime.setUTCMilliseconds(-1);\n          recordCopy.endBrokerTime = moment(startBrokerTime).format('YYYY-MM-DD HH:mm:ss.SSS');\n          recordCopy.brokerTime = recordCopy.endBrokerTime;\n          records.splice(i + 1, 0, recordCopy);\n        }\n        i++;\n      }  \n    }\n    return records;\n  }\n\n  /**\n   * Adds an equity chart event listener\n   * @param {EquityChartListener} listener equity chart event listener\n   * @param {String} accountId account id\n   * @param {Date} [startTime] date to start tracking from\n   * @returns {Promise<string>} listener id\n   */\n  addEquityChartListener(listener, accountId, startTime) {\n    return this._equityChartStreamManager.addEquityChartListener(listener, accountId, startTime);\n  }\n\n  /**\n   * Removes equity chart event listener by id\n   * @param {String} listenerId equity chart listener id \n   */\n  removeEquityChartListener(listenerId) {\n    this._equityChartStreamManager.removeEquityChartListener(listenerId);\n  }\n\n  /**\n   * Adds an equity balance event listener\n   * @param {EquityBalanceListener} listener equity balance event listener\n   * @param {string} accountId account id\n   * @returns {Promise<string>} listener id\n   */\n  addEquityBalanceListener(listener, accountId) {\n    return this._equityBalanceStreamManager.addEquityBalanceListener(listener, accountId);\n  }\n\n  /**\n   * Removes equity balance event listener by id\n   * @param {string} listenerId equity balance listener id \n   */\n  removeEquityBalanceListener(listenerId) {\n    this._equityBalanceStreamManager.removeEquityBalanceListener(listenerId);\n  }\n\n}\n"],"names":["TrackerEventListenerManager","PeriodStatisticsStreamManager","EquityChartStreamManager","EquityBalanceStreamManager","moment","EquityTrackingClient","createTracker","accountId","tracker","_domainClient","requestApi","url","headers","token","method","data","getTrackers","getTracker","id","getTrackerByName","name","encodeURIComponent","updateTracker","update","deleteTracker","getTrackerEvents","startBrokerTime","endBrokerTime","trackerId","limit","params","addTrackerEventListener","listener","sequenceNumber","_trackerEventListenerManager","removeTrackerEventListener","listenerId","getTrackingStatistics","startTime","realTime","addPeriodStatisticsListener","_periodStatisticsStreamManager","removePeriodStatisticsListener","getEquityChart","endTime","fillSkips","records","i","length","timeDiff","Date","getTime","lastBalance","undefined","recordCopy","JSON","parse","stringify","minEquity","lastEquity","maxEquity","averageEquity","minBalance","maxBalance","averageBalance","setUTCHours","getUTCHours","setUTCMinutes","setUTCSeconds","setUTCMilliseconds","format","brokerTime","splice","addEquityChartListener","_equityChartStreamManager","removeEquityChartListener","addEquityBalanceListener","_equityBalanceStreamManager","removeEquityBalanceListener","constructor","domainClient","metaApi"],"mappings":"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