metaapi.cloud-sdk
Version:
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)
575 lines • 80 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return _default;
}
});
const _timeoutError = /*#__PURE__*/ _interop_require_default(require("../clients/timeoutError"));
const _expertAdvisor = /*#__PURE__*/ _interop_require_default(require("./expertAdvisor"));
const _errorHandler = require("../clients/errorHandler");
const _metatraderAccountReplica = /*#__PURE__*/ _interop_require_default(require("./metatraderAccountReplica"));
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
const HistoryDatabase = require("./historyDatabase/index").default;
/**
* Implements a MetaTrader account entity
*/ let MetatraderAccount = class MetatraderAccount {
/**
* Returns unique account id
* @return {string} unique account id
*/ get id() {
return this._data._id;
}
/**
* Returns current account state. One of CREATED, DEPLOYING, DEPLOYED, DEPLOY_FAILED, UNDEPLOYING,
* UNDEPLOYED, UNDEPLOY_FAILED, DELETING, DELETE_FAILED, REDEPLOY_FAILED, DRAFT
* @return {State} current account state
*/ get state() {
return this._data.state;
}
/**
* Returns MetaTrader magic to place trades using
* @return {number} MetaTrader magic to place trades using
*/ get magic() {
return this._data.magic;
}
/**
* Returns terminal & broker connection status, one of CONNECTED, DISCONNECTED, DISCONNECTED_FROM_BROKER
* @return {ConnectionStatus} terminal & broker connection status
*/ get connectionStatus() {
return this._data.connectionStatus;
}
/**
* Returns quote streaming interval in seconds
* @return {number} quote streaming interval in seconds
*/ get quoteStreamingIntervalInSeconds() {
return this._data.quoteStreamingIntervalInSeconds;
}
/**
* Returns symbol provided by broker
* @return {string} any symbol provided by broker
*/ get symbol() {
return this._data.symbol;
}
/**
* Returns reliability value. Possible values are regular and high
* @return {Reliability} account reliability value
*/ get reliability() {
return this._data.reliability;
}
/**
* Returns user-defined account tags
* @return {Array<string>} user-defined account tags
*/ get tags() {
return this._data.tags;
}
/**
* Returns extra information which can be stored together with your account
* @return {Object} extra information which can be stored together with your account
*/ get metadata() {
return this._data.metadata;
}
/**
* Returns number of resource slots to allocate to account. Allocating extra resource slots
* results in better account performance under load which is useful for some applications. E.g. if you have many
* accounts copying the same strategy via CopyFactory API, then you can increase resourceSlots to get a lower trade
* copying latency. Please note that allocating extra resource slots is a paid option. Please note that high
* reliability accounts use redundant infrastructure, so that each resource slot for a high reliability account
* is billed as 2 standard resource slots.
* @return {number} number of resource slots to allocate to account
*/ get resourceSlots() {
return this._data.resourceSlots;
}
/**
* Returns the number of CopyFactory 2 resource slots to allocate to account.
* Allocating extra resource slots results in lower trade copying latency. Please note that allocating extra resource
* slots is a paid option. Please also note that CopyFactory 2 uses redundant infrastructure so that
* each CopyFactory resource slot is billed as 2 standard resource slots. You will be billed for CopyFactory 2
* resource slots only if you have added your account to CopyFactory 2 by specifying copyFactoryRoles field.
* @return {number} number of CopyFactory 2 resource slots to allocate to account
*/ get copyFactoryResourceSlots() {
return this._data.copyFactoryResourceSlots;
}
/**
* Returns account region
* @return {string} account region value
*/ get region() {
return this._data.region;
}
/**
* Returns the time account was created at, in ISO format
* @returns {string} the time account was created at, in ISO format
*/ get createdAt() {
return new Date(this._data.createdAt);
}
/**
* Returns human-readable account name
* @return {string} human-readable account name
*/ get name() {
return this._data.name;
}
/**
* Returns flag indicating if trades should be placed as manual trades on this account
* @return {boolean} flag indicating if trades should be placed as manual trades on this account
*/ get manualTrades() {
return this._data.manualTrades;
}
/**
* Returns default trade slippage in points
* @return {number} default trade slippage in points
*/ get slippage() {
return this._data.slippage;
}
/**
* Returns id of the account's provisioning profile
* @return {string} id of the account's provisioning profile
*/ get provisioningProfileId() {
return this._data.provisioningProfileId;
}
/**
* Returns MetaTrader account login
* @return {string} MetaTrader account number
*/ get login() {
return this._data.login;
}
/**
* Returns MetaTrader server name to connect to
* @return {string} MetaTrader server name to connect to
*/ get server() {
return this._data.server;
}
/**
* Returns account type. Possible values are cloud-g1, cloud-g2
* @return {Type} account type
*/ get type() {
return this._data.type;
}
/**
* Returns MT version. Possible values are 4 and 5
* @return {Version} MT version
*/ get version() {
return this._data.version;
}
/**
* Returns hash-code of the account
* @return {number} hash-code of the account
*/ get hash() {
return this._data.hash;
}
/**
* Returns 3-character ISO currency code of the account base currency. The setting is to be used
* for copy trading accounts which use national currencies only, such as some Brazilian brokers. You should not alter
* this setting unless you understand what you are doing.
* @return {string} 3-character ISO currency code of the account base currency
*/ get baseCurrency() {
return this._data.baseCurrency;
}
/**
* Returns account roles for CopyFactory2 application. Possible values are `PROVIDER` and `SUBSCRIBER`
* @return {Array<CopyFactoryRoles>} account roles for CopyFactory2 application
*/ get copyFactoryRoles() {
return this._data.copyFactoryRoles;
}
/**
* Returns flag indicating that risk management API is enabled on account
* @return {boolean} flag indicating that risk management API is enabled on account
*/ get riskManagementApiEnabled() {
return this._data.riskManagementApiEnabled;
}
/**
* Returns flag indicating that MetaStats API is enabled on account
* @return {boolean} flag indicating that MetaStats API is enabled on account
*/ get metastatsApiEnabled() {
return this._data.metastatsApiEnabled;
}
/**
* Returns configured dedicated IP protocol to connect to the trading account terminal
* @return {DedicatedIp}
*/ get allocateDedicatedIp() {
return this._data.allocateDedicatedIp;
}
/**
* Returns active account connections
* @return {Array<AccountConnection>} active account connections
*/ get connections() {
return this._data.connections;
}
/**
* Returns flag indicating that account is primary
* @return {boolean} flag indicating that account is primary
*/ get primaryReplica() {
return this._data.primaryReplica;
}
/**
* Returns user id
* @return {string} user id
*/ get userId() {
return this._data.userId;
}
/**
* Returns primary account id
* @return {string} primary account id
*/ get primaryAccountId() {
return this._data.primaryAccountId;
}
/**
* Returns account replicas from DTO
* @return {MetatraderAccountReplica[]} account replicas from DTO
*/ get accountReplicas() {
return this._data.accountReplicas;
}
/**
* Returns account replica instances
* @return {MetatraderAccountReplica[]} account replica instances
*/ get replicas() {
return this._replicas;
}
/**
* Returns a dictionary with account's available regions and replicas
* @returns accounts by region
*/ get accountRegions() {
const regions = {
[this.region]: this.id
};
this.replicas.forEach((replica)=>regions[replica.region] = replica.id);
return regions;
}
/**
* Reloads MetaTrader account from API
* @return {Promise} promise resolving when MetaTrader account is updated
*/ async reload() {
this._data = await this._metatraderAccountClient.getAccount(this.id);
const updatedReplicaData = this._data.accountReplicas || [];
const regions = updatedReplicaData.map((replica)=>replica.region);
const createdReplicaRegions = this._replicas.map((replica)=>replica.region);
this._replicas = this._replicas.filter((replica)=>regions.includes(replica.region));
this._replicas.forEach((replica)=>{
const updatedData = updatedReplicaData.find((replicaData)=>replicaData.region === replica.region);
replica.updateData(updatedData);
});
updatedReplicaData.forEach((replica)=>{
if (!createdReplicaRegions.includes(replica.region)) {
this._replicas.push(new _metatraderAccountReplica.default(replica, this, this._metatraderAccountClient));
}
});
}
/**
* Removes a trading account and stops the API server serving the account.
* The account state such as downloaded market data history will be removed as well when you remove the account.
* @return {Promise} promise resolving when account is scheduled for deletion
*/ async remove() {
this._connectionRegistry.closeAllInstances(this.id);
await this._metatraderAccountClient.deleteAccount(this.id);
const fileManager = HistoryDatabase.getInstance();
await fileManager.clear(this.id, this._application);
if (this.type !== "self-hosted") {
try {
await this.reload();
} catch (err) {
if (err.name !== "NotFoundError") {
throw err;
}
}
}
}
/**
* Starts API server and trading terminal for trading account.
* This request will be ignored if the account is already deployed.
* @returns {Promise} promise resolving when account is scheduled for deployment
*/ async deploy() {
await this._metatraderAccountClient.deployAccount(this.id);
await this.reload();
}
/**
* Stops API server and trading terminal for trading account.
* This request will be ignored if trading account is already undeployed
* @returns {Promise} promise resolving when account is scheduled for undeployment
*/ async undeploy() {
this._connectionRegistry.closeAllInstances(this.id);
await this._metatraderAccountClient.undeployAccount(this.id);
await this.reload();
}
/**
* Redeploys trading account. This is equivalent to undeploy immediately followed by deploy
* @returns {Promise} promise resolving when account is scheduled for redeployment
*/ async redeploy() {
await this._metatraderAccountClient.redeployAccount(this.id);
await this.reload();
}
/**
* Increases trading account reliability in order to increase the expected account uptime.
* The account will be temporary stopped to perform this action.
* Note that increasing reliability is a paid option
* @returns {Promise} promise resolving when account reliability is increased
*/ async increaseReliability() {
await this._metatraderAccountClient.increaseReliability(this.id);
await this.reload();
}
/**
* Enables risk management API for trading account.
* The account will be temporary stopped to perform this action.
* Note that risk management API is a paid option
* @returns {Promise} promise resolving when account risk management is enabled
*/ async enableRiskManagementApi() {
await this._metatraderAccountClient.enableRiskManagementApi(this.id);
await this.reload();
}
/**
* Enables copy factory API for trading account.
* The account will be temporary stopped to perform this action.
* Note that copy factory API is a paid option (see
* @param {Array<CopyFactoryRoles>} copyFactoryRoles copy factory roles
* @param {number} copyFactoryResourceSlots copy factory resource slots
* @return {Promise} promise resolving when account copy factory is enabled
*/ async enableCopyFactoryApi(copyFactoryRoles, copyFactoryResourceSlots) {
await this._metatraderAccountClient.enableCopyFactoryApi(this.id, copyFactoryRoles, copyFactoryResourceSlots);
await this.reload();
}
/**
* Enables MetaStats API for trading account.
* The account will be temporary stopped to perform this action.
* Note that this is a paid option
* @returns {Promise} promise resolving when account MetaStats API is enabled
*/ async enableMetaStatsApi() {
await this._metatraderAccountClient.enableMetaStatsApi(this.id);
await this.reload();
}
/**
* Waits until API server has finished deployment and account reached the DEPLOYED state
* @param {number} timeoutInSeconds wait timeout in seconds, default is 5m
* @param {number} intervalInMilliseconds interval between account reloads while waiting for a change, default is 1s
* @return {Promise} promise which resolves when account is deployed
* @throws {TimeoutError} if account have not reached the DEPLOYED state within timeout allowed
*/ async waitDeployed(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
let startTime = Date.now();
await this.reload();
while(this.state !== "DEPLOYED" && startTime + timeoutInSeconds * 1000 > Date.now()){
await this._delay(intervalInMilliseconds);
await this.reload();
}
if (this.state !== "DEPLOYED") {
throw new _timeoutError.default("Timed out waiting for account " + this.id + " to be deployed");
}
}
/**
* Waits until API server has finished undeployment and account reached the UNDEPLOYED state
* @param {number} timeoutInSeconds wait timeout in seconds, default is 5m
* @param {number} intervalInMilliseconds interval between account reloads while waiting for a change, default is 1s
* @return {Promise} promise which resolves when account is deployed
* @throws {TimeoutError} if account have not reached the UNDEPLOYED state within timeout allowed
*/ async waitUndeployed(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
let startTime = Date.now();
await this.reload();
while(this.state !== "UNDEPLOYED" && startTime + timeoutInSeconds * 1000 > Date.now()){
await this._delay(intervalInMilliseconds);
await this.reload();
}
if (this.state !== "UNDEPLOYED") {
throw new _timeoutError.default("Timed out waiting for account " + this.id + " to be undeployed");
}
}
/**
* Waits until account has been deleted
* @param {number} timeoutInSeconds wait timeout in seconds, default is 5m
* @param {number} intervalInMilliseconds interval between account reloads while waiting for a change, default is 1s
* @return {Promise} promise which resolves when account is deleted
* @throws {TimeoutError} if account was not deleted within timeout allowed
*/ async waitRemoved(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
let startTime = Date.now();
try {
await this.reload();
while(startTime + timeoutInSeconds * 1000 > Date.now()){
await this._delay(intervalInMilliseconds);
await this.reload();
}
throw new _timeoutError.default("Timed out waiting for account " + this.id + " to be deleted");
} catch (err) {
if (err.name === "NotFoundError") {
return;
} else {
throw err;
}
}
}
/**
* Waits until API server has connected to the terminal and terminal has connected to the broker
* @param {number} timeoutInSeconds wait timeout in seconds, default is 5m
* @param {number} intervalInMilliseconds interval between account reloads while waiting for a change, default is 1s
* @return {Promise} promise which resolves when API server is connected to the broker
* @throws {TimeoutError} if account have not connected to the broker within timeout allowed
*/ async waitConnected(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {
const checkConnected = ()=>{
return [
this.connectionStatus
].concat(this.replicas.map((replica)=>replica.connectionStatus)).includes("CONNECTED");
};
let startTime = Date.now();
await this.reload();
while(!checkConnected() && startTime + timeoutInSeconds * 1000 > Date.now()){
await this._delay(intervalInMilliseconds);
await this.reload();
}
if (!checkConnected()) {
throw new _timeoutError.default("Timed out waiting for account " + this.id + " to connect to the broker");
}
}
/**
* Connects to MetaApi. There is only one connection per account. Subsequent calls to this method will return the same connection.
* @param {HistoryStorage} historyStorage optional history storage
* @param {Date} [historyStartTime] history start time. Used for tests
* @return {StreamingMetaApiConnectionInstance} MetaApi connection instance
*/ getStreamingConnection(historyStorage, historyStartTime) {
if (this._metaApiWebsocketClient.region && this._metaApiWebsocketClient.region !== this.region) {
throw new _errorHandler.ValidationError(`Account ${this.id} is not on specified region ${this._metaApiWebsocketClient.region}`);
}
return this._connectionRegistry.connectStreaming(this, historyStorage, historyStartTime);
}
/**
* Connects to MetaApi via RPC connection instance.
* @returns {RpcMetaApiConnectionInstance} MetaApi connection instance
*/ getRPCConnection() {
if (this._metaApiWebsocketClient.region && this._metaApiWebsocketClient.region !== this.region) {
throw new _errorHandler.ValidationError(`Account ${this.id} is not on specified region ${this._metaApiWebsocketClient.region}`);
}
return this._connectionRegistry.connectRpc(this);
}
/**
* Updates trading account.
* Please redeploy the trading account in order for updated settings to take effect
* @param {MetatraderAccountUpdateDto} account updated account information
* @return {Promise} promise resolving when account is updated
*/ async update(account) {
await this._metatraderAccountClient.updateAccount(this.id, account);
await this.reload();
}
/**
* Creates a trading account replica in a region different from trading account region and starts a cloud API server for it
* @param {NewMetaTraderAccountDto} account MetaTrader account data
* @return {Promise<MetatraderAccountReplica>} promise resolving with created MetaTrader account replica entity
*/ async createReplica(account) {
await this._metatraderAccountClient.createAccountReplica(this.id, account);
await this.reload();
return this._replicas.find((r)=>r.region === account.region);
}
/**
* Retrieves expert advisor of current account
* @returns {Promise<ExpertAdvisor[]>} promise resolving with an array of expert advisor entities
*/ async getExpertAdvisors() {
this._checkExpertAdvisorAllowed();
let expertAdvisors = await this._expertAdvisorClient.getExpertAdvisors(this.id);
return expertAdvisors.map((e)=>new _expertAdvisor.default(e, this.id, this._expertAdvisorClient));
}
/**
* Retrieves a expert advisor of current account by id
* @param {String} expertId expert advisor id
* @returns {Promise<ExpertAdvisor>} promise resolving with expert advisor entity
*/ async getExpertAdvisor(expertId) {
this._checkExpertAdvisorAllowed();
let expertAdvisor = await this._expertAdvisorClient.getExpertAdvisor(this.id, expertId);
return new _expertAdvisor.default(expertAdvisor, this.id, this._expertAdvisorClient);
}
/**
* Creates an expert advisor
* @param {string} expertId expert advisor id
* @param {NewExpertAdvisorDto} expert expert advisor data
* @returns {Promise<ExpertAdvisor>} promise resolving with expert advisor entity
*/ async createExpertAdvisor(expertId, expert) {
this._checkExpertAdvisorAllowed();
await this._expertAdvisorClient.updateExpertAdvisor(this.id, expertId, expert);
return this.getExpertAdvisor(expertId);
}
/**
* Returns historical candles for a specific symbol and timeframe from the MetaTrader account.
* See https://metaapi.cloud/docs/client/restApi/api/retrieveMarketData/readHistoricalCandles/
* @param {string} symbol symbol to retrieve candles for (e.g. a currency pair or an index)
* @param {string} timeframe defines the timeframe according to which the candles must be generated. Allowed values
* for MT5 are 1m, 2m, 3m, 4m, 5m, 6m, 10m, 12m, 15m, 20m, 30m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1d, 1w, 1mn. Allowed
* values for MT4 are 1m, 5m, 15m 30m, 1h, 4h, 1d, 1w, 1mn
* @param {Date} [startTime] time to start loading candles from. Note that candles are loaded in backwards direction, so
* this should be the latest time. Leave empty to request latest candles.
* @param {number} [limit] maximum number of candles to retrieve. Must be less or equal to 1000
* @return {Promise<Array<MetatraderCandle>>} promise resolving with historical candles downloaded
*/ getHistoricalCandles(symbol, timeframe, startTime, limit) {
return this._historicalMarketDataClient.getHistoricalCandles(this.id, this.region, symbol, timeframe, startTime, limit);
}
/**
* Returns historical ticks for a specific symbol from the MetaTrader account. This API is not supported by MT4
* accounts.
* See https://metaapi.cloud/docs/client/restApi/api/retrieveMarketData/readHistoricalTicks/
* @param {string} symbol symbol to retrieve ticks for (e.g. a currency pair or an index)
* @param {Date} [startTime] time to start loading ticks from. Note that candles are loaded in forward direction, so
* this should be the earliest time. Leave empty to request latest candles.
* @param {number} [offset] number of ticks to skip (you can use it to avoid requesting ticks from previous request
* twice)
* @param {number} [limit] maximum number of ticks to retrieve. Must be less or equal to 1000
* @return {Promise<Array<MetatraderTick>>} promise resolving with historical ticks downloaded
*/ getHistoricalTicks(symbol, startTime, offset, limit) {
return this._historicalMarketDataClient.getHistoricalTicks(this.id, this.region, symbol, startTime, offset, limit);
}
/**
* Generates trading account configuration link by account id.
* @param {number} [ttlInDays] Lifetime of the link in days. Default is 7.
* @return {Promise<ConfigurationLink>} promise resolving with configuration link
*/ async createConfigurationLink(ttlInDays) {
const configurationLink = await this._metatraderAccountClient.createConfigurationLink(this.id, ttlInDays);
return configurationLink;
}
_checkExpertAdvisorAllowed() {
if (this.version !== 4 || this.type !== "cloud-g1") {
throw new _errorHandler.ValidationError("Custom expert advisor is available only for MT4 G1 accounts");
}
}
_delay(timeoutInMilliseconds) {
return new Promise((res)=>setTimeout(res, timeoutInMilliseconds));
}
/**
* Constructs a MetaTrader account entity
* @param {MetatraderAccountDto} data MetaTrader account data
* @param {MetatraderAccountClient} metatraderAccountClient MetaTrader account REST API client
* @param {MetaApiWebsocketClient} metaApiWebsocketClient MetaApi websocket client
* @param {ConnectionRegistry} connectionRegistry metatrader account connection registry
* @param {ExpertAdvisorClient} expertAdvisorClient expert advisor REST API client
* @param {HistoricalMarketDataClient} historicalMarketDataClient historical market data HTTP API client
* @param {string} application application name
*/ constructor(data, metatraderAccountClient, metaApiWebsocketClient, connectionRegistry, expertAdvisorClient, historicalMarketDataClient, application){
_define_property(this, "_data", void 0);
_define_property(this, "_metatraderAccountClient", void 0);
_define_property(this, "_metaApiWebsocketClient", void 0);
_define_property(this, "_connectionRegistry", void 0);
_define_property(this, "_expertAdvisorClient", void 0);
_define_property(this, "_historicalMarketDataClient", void 0);
_define_property(this, "_application", void 0);
_define_property(this, "_replicas", void 0);
this._data = data;
this._metatraderAccountClient = metatraderAccountClient;
this._metaApiWebsocketClient = metaApiWebsocketClient;
this._connectionRegistry = connectionRegistry;
this._expertAdvisorClient = expertAdvisorClient;
this._historicalMarketDataClient = historicalMarketDataClient;
this._application = application;
this._replicas = (data.accountReplicas || []).map((replica)=>new _metatraderAccountReplica.default(replica, this, metatraderAccountClient));
}
};
const _default = MetatraderAccount;
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport TimeoutError from '../clients/timeoutError';\nimport RpcMetaApiConnectionInstance from './rpcMetaApiConnectionInstance';\nimport StreamingMetaApiConnectionInstance from './streamingMetaApiConnectionInstance';\nconst HistoryDatabase = require('./historyDatabase/index').default;\nimport ExpertAdvisor from './expertAdvisor';\nimport {ValidationError} from '../clients/errorHandler';\nimport MetatraderAccountReplica from './metatraderAccountReplica';\n//eslint-disable-next-line max-len\nimport MetatraderAccountClient, {\n  Reliability, State, Version, ConnectionStatus, CopyFactoryRoles, Type, AccountConnection, ConfigurationLink,\n  MetatraderAccountDto, DedicatedIp,\n  NewMetaTraderAccountReplicaDto,\n  MetatraderAccountUpdateDto\n} from '../clients/metaApi/metatraderAccount.client';\nimport type ConnectionRegistry from './connectionRegistry';\nimport type MetaApiWebsocketClient from '../clients/metaApi/metaApiWebsocket.client';\nimport type ExpertAdvisorClient from '../clients/metaApi/expertAdvisor.client';\nimport type HistoricalMarketDataClient from '../clients/metaApi/historicalMarketData.client';\nimport HistoryStorage from './historyStorage';\nimport {NewExpertAdvisorDto} from '../clients/metaApi/expertAdvisor.client';\nimport {MetatraderCandle, MetatraderTick} from '../clients/metaApi/metaApiWebsocket.client';\n\n/**\n * Implements a MetaTrader account entity\n */\nclass MetatraderAccount {\n  \n  private _data: any;\n  private _metatraderAccountClient: any;\n  private _metaApiWebsocketClient: any;\n  private _connectionRegistry: any;\n  private _expertAdvisorClient: any;\n  private _historicalMarketDataClient: any;\n  private _application: any;\n  private _replicas: any;\n\n  /**\n   * Constructs a MetaTrader account entity\n   * @param {MetatraderAccountDto} data MetaTrader account data\n   * @param {MetatraderAccountClient} metatraderAccountClient MetaTrader account REST API client\n   * @param {MetaApiWebsocketClient} metaApiWebsocketClient MetaApi websocket client\n   * @param {ConnectionRegistry} connectionRegistry metatrader account connection registry\n   * @param {ExpertAdvisorClient} expertAdvisorClient expert advisor REST API client\n   * @param {HistoricalMarketDataClient} historicalMarketDataClient historical market data HTTP API client\n   * @param {string} application application name\n   */\n  constructor(\n    data: MetatraderAccountDto, metatraderAccountClient: MetatraderAccountClient,\n    metaApiWebsocketClient: MetaApiWebsocketClient, connectionRegistry: ConnectionRegistry,\n    expertAdvisorClient: ExpertAdvisorClient, historicalMarketDataClient: HistoricalMarketDataClient,\n    application: string\n  ) {\n    this._data = data;\n    this._metatraderAccountClient = metatraderAccountClient;\n    this._metaApiWebsocketClient = metaApiWebsocketClient;\n    this._connectionRegistry = connectionRegistry;\n    this._expertAdvisorClient = expertAdvisorClient;\n    this._historicalMarketDataClient = historicalMarketDataClient;\n    this._application = application;\n    this._replicas = (data.accountReplicas || [])\n      .map(replica => new MetatraderAccountReplica(replica, this, metatraderAccountClient));\n  }\n\n  /**\n   * Returns unique account id\n   * @return {string} unique account id\n   */\n  get id(): string {\n    return this._data._id;\n  }\n\n  /**\n   * Returns current account state. One of CREATED, DEPLOYING, DEPLOYED, DEPLOY_FAILED, UNDEPLOYING,\n   * UNDEPLOYED, UNDEPLOY_FAILED, DELETING, DELETE_FAILED, REDEPLOY_FAILED, DRAFT\n   * @return {State} current account state\n   */\n  get state(): State {\n    return this._data.state;\n  }\n\n  /**\n   * Returns MetaTrader magic to place trades using\n   * @return {number} MetaTrader magic to place trades using\n   */\n  get magic(): number {\n    return this._data.magic;\n  }\n\n  /**\n   * Returns terminal & broker connection status, one of CONNECTED, DISCONNECTED, DISCONNECTED_FROM_BROKER\n   * @return {ConnectionStatus} terminal & broker connection status\n   */\n  get connectionStatus(): ConnectionStatus {\n    return this._data.connectionStatus;\n  }\n  \n  /**\n   * Returns quote streaming interval in seconds \n   * @return {number} quote streaming interval in seconds\n   */\n  get quoteStreamingIntervalInSeconds(): number {\n    return this._data.quoteStreamingIntervalInSeconds;\n  }\n  \n  /**\n   * Returns symbol provided by broker \n   * @return {string} any symbol provided by broker\n   */\n  get symbol(): string {\n    return this._data.symbol;\n  }\n  \n  /**\n   * Returns reliability value. Possible values are regular and high\n   * @return {Reliability} account reliability value\n   */\n  get reliability(): Reliability {\n    return this._data.reliability;\n  }\n  \n  /**\n   * Returns user-defined account tags\n   * @return {Array<string>} user-defined account tags\n   */\n  get tags(): Array<string> {\n    return this._data.tags;\n  }\n\n  /**\n   * Returns extra information which can be stored together with your account\n   * @return {Object} extra information which can be stored together with your account\n   */\n  get metadata(): Object {\n    return this._data.metadata;\n  }\n\n  /**\n   * Returns number of resource slots to allocate to account. Allocating extra resource slots\n   * results in better account performance under load which is useful for some applications. E.g. if you have many\n   * accounts copying the same strategy via CopyFactory API, then you can increase resourceSlots to get a lower trade\n   * copying latency. Please note that allocating extra resource slots is a paid option. Please note that high\n   * reliability accounts use redundant infrastructure, so that each resource slot for a high reliability account\n   * is billed as 2 standard resource slots.\n   * @return {number} number of resource slots to allocate to account\n   */\n  get resourceSlots(): number {\n    return this._data.resourceSlots;\n  }\n\n  /**\n   * Returns the number of CopyFactory 2 resource slots to allocate to account.\n   * Allocating extra resource slots results in lower trade copying latency. Please note that allocating extra resource\n   * slots is a paid option. Please also note that CopyFactory 2 uses redundant infrastructure so that\n   * each CopyFactory resource slot is billed as 2 standard resource slots. You will be billed for CopyFactory 2\n   * resource slots only if you have added your account to CopyFactory 2 by specifying copyFactoryRoles field.\n   * @return {number} number of CopyFactory 2 resource slots to allocate to account\n   */\n  get copyFactoryResourceSlots(): number {\n    return this._data.copyFactoryResourceSlots;\n  }\n\n  /**\n   * Returns account region\n   * @return {string} account region value\n   */\n  get region(): string {\n    return this._data.region;\n  }\n\n  /**\n   * Returns the time account was created at, in ISO format\n   * @returns {string} the time account was created at, in ISO format\n   */\n  get createdAt(): Date {\n    return new Date(this._data.createdAt);\n  }\n\n  /**\n   * Returns human-readable account name\n   * @return {string} human-readable account name\n   */\n  get name(): string {\n    return this._data.name;\n  }\n  \n  /**\n   * Returns flag indicating if trades should be placed as manual trades on this account\n   * @return {boolean} flag indicating if trades should be placed as manual trades on this account\n   */\n  get manualTrades(): boolean {\n    return this._data.manualTrades;\n  }\n\n  /**\n   * Returns default trade slippage in points\n   * @return {number} default trade slippage in points\n   */\n  get slippage(): number {\n    return this._data.slippage;\n  }\n  \n  /**\n   * Returns id of the account's provisioning profile\n   * @return {string} id of the account's provisioning profile\n   */\n  get provisioningProfileId(): string {\n    return this._data.provisioningProfileId;\n  }\n  \n  /**\n   * Returns MetaTrader account login\n   * @return {string} MetaTrader account number\n   */\n  get login(): string {\n    return this._data.login;\n  }\n  \n  /**\n   * Returns MetaTrader server name to connect to\n   * @return {string} MetaTrader server name to connect to\n   */\n  get server(): string {\n    return this._data.server;\n  }\n\n  /**\n   * Returns account type. Possible values are cloud-g1, cloud-g2\n   * @return {Type} account type\n   */\n  get type(): Type {\n    return this._data.type;\n  }\n\n  /**\n   * Returns MT version. Possible values are 4 and 5\n   * @return {Version} MT version\n   */\n  get version(): Version {\n    return this._data.version;\n  }\n\n  /**\n   * Returns hash-code of the account\n   * @return {number} hash-code of the account\n   */\n  get hash(): number {\n    return this._data.hash;\n  }\n\n  /**\n   * Returns 3-character ISO currency code of the account base currency. The setting is to be used\n   * for copy trading accounts which use national currencies only, such as some Brazilian brokers. You should not alter\n   * this setting unless you understand what you are doing.\n   * @return {string} 3-character ISO currency code of the account base currency\n   */\n  get baseCurrency(): string {\n    return this._data.baseCurrency;\n  }\n\n  /**\n   * Returns account roles for CopyFactory2 application. Possible values are `PROVIDER` and `SUBSCRIBER`\n   * @return {Array<CopyFactoryRoles>} account roles for CopyFactory2 application\n   */\n  get copyFactoryRoles(): Array<CopyFactoryRoles> {\n    return this._data.copyFactoryRoles;\n  }\n  \n  /**\n   * Returns flag indicating that risk management API is enabled on account\n   * @return {boolean} flag indicating that risk management API is enabled on account\n   */\n  get riskManagementApiEnabled(): boolean {\n    return this._data.riskManagementApiEnabled;\n  }\n\n  /**\n   * Returns flag indicating that MetaStats API is enabled on account\n   * @return {boolean} flag indicating that MetaStats API is enabled on account\n   */\n  get metastatsApiEnabled(): boolean {\n    return this._data.metastatsApiEnabled;\n  }\n\n  /**\n   * Returns configured dedicated IP protocol to connect to the trading account terminal\n   * @return {DedicatedIp}\n   */\n  get allocateDedicatedIp(): DedicatedIp {\n    return this._data.allocateDedicatedIp;\n  }\n    \n  /**\n   * Returns active account connections\n   * @return {Array<AccountConnection>} active account connections\n   */\n  get connections(): Array<AccountConnection> {\n    return this._data.connections;\n  }\n\n  /**\n   * Returns flag indicating that account is primary\n   * @return {boolean} flag indicating that account is primary\n   */\n  get primaryReplica(): boolean {\n    return this._data.primaryReplica;\n  }\n\n  /**\n   * Returns user id\n   * @return {string} user id\n   */\n  get userId(): string {\n    return this._data.userId;\n  }\n\n  /**\n   * Returns primary account id\n   * @return {string} primary account id\n   */\n  get primaryAccountId(): string {\n    return this._data.primaryAccountId;\n  }\n\n  /**\n   * Returns account replicas from DTO\n   * @return {MetatraderAccountReplica[]} account replicas from DTO\n   */\n  get accountReplicas(): MetatraderAccountReplica[] {\n    return this._data.accountReplicas;\n  }\n\n  /**\n   * Returns account replica instances\n   * @return {MetatraderAccountReplica[]} account replica instances\n   */\n  get replicas(): MetatraderAccountReplica[] {\n    return this._replicas;\n  }\n\n  /**\n   * Returns a dictionary with account's available regions and replicas\n   * @returns accounts by region\n   */\n  get accountRegions(): MetatraderAccount.AccountsByRegion {\n    const regions = {[this.region]: this.id};\n    this.replicas.forEach(replica => regions[replica.region] = replica.id);\n    return regions;\n  }\n\n  /**\n   * Reloads MetaTrader account from API\n   * @return {Promise} promise resolving when MetaTrader account is updated\n   */\n  async reload() {\n    this._data = await this._metatraderAccountClient.getAccount(this.id);\n    const updatedReplicaData = (this._data.accountReplicas || []);\n    const regions = updatedReplicaData.map(replica => replica.region);\n    const createdReplicaRegions = this._replicas.map(replica => replica.region);\n    this._replicas = this._replicas.filter(replica => regions.includes(replica.region));\n    this._replicas.forEach(replica => {\n      const updatedData = updatedReplicaData.find(replicaData => replicaData.region === replica.region);\n      replica.updateData(updatedData);\n    });\n    updatedReplicaData.forEach(replica => {\n      if(!createdReplicaRegions.includes(replica.region)) {\n        this._replicas.push(new MetatraderAccountReplica(replica, this, this._metatraderAccountClient));\n      }\n    });\n  }\n\n  /**\n   * Removes a trading account and stops the API server serving the account.\n   * The account state such as downloaded market data history will be removed as well when you remove the account.\n   * @return {Promise} promise resolving when account is scheduled for deletion\n   */\n  async remove() {\n    this._connectionRegistry.closeAllInstances(this.id);\n    await this._metatraderAccountClient.deleteAccount(this.id);\n    const fileManager = HistoryDatabase.getInstance();\n    await fileManager.clear(this.id, this._application);\n    if ((this.type as any) !== 'self-hosted') {\n      try {\n        await this.reload();\n      } catch (err) {\n        if (err.name !== 'NotFoundError') {\n          throw err;\n        }\n      }\n    }\n  }\n\n  /**\n   * Starts API server and trading terminal for trading account.\n   * This request will be ignored if the account is already deployed.\n   * @returns {Promise} promise resolving when account is scheduled for deployment\n   */\n  async deploy() {\n    await this._metatraderAccountClient.deployAccount(this.id);\n    await this.reload();\n  }\n\n  /**\n   * Stops API server and trading terminal for trading account.\n   * This request will be ignored if trading account is already undeployed\n   * @returns {Promise} promise resolving when account is scheduled for undeployment\n   */\n  async undeploy() {\n    this._connectionRegistry.closeAllInstances(this.id);\n    await this._metatraderAccountClient.undeployAccount(this.id);\n    await this.reload();\n  }\n\n  /**\n   * Redeploys trading account. This is equivalent to undeploy immediately followed by deploy\n   * @returns {Promise} promise resolving when account is scheduled for redeployment\n   */\n  async redeploy() {\n    await this._metatraderAccountClient.redeployAccount(this.id);\n    await this.reload();\n  }\n\n  /**\n   * Increases trading account reliability in order to increase the expected account uptime.\n   * The account will be temporary stopped to perform this action.\n   * Note that increasing reliability is a paid option\n   * @returns {Promise} promise resolving when account reliability is increased\n   */\n  async increaseReliability() {\n    await this._metatraderAccountClient.increaseReliability(this.id);\n    await this.reload();\n  }\n\n  /**\n   * Enables risk management API for trading account.\n   * The account will be temporary stopped to perform this action.\n   * Note that risk management API is a paid option\n   * @returns {Promise} promise resolving when account risk management is enabled\n   */\n  async enableRiskManagementApi() {\n    await this._metatraderAccountClient.enableRiskManagementApi(this.id);\n    await this.reload();\n  }\n\n  /**\n   * Enables copy factory API for trading account.\n   * The account will be temporary stopped to perform this action.\n   * Note that copy factory API is a paid option (see\n   * @param {Array<CopyFactoryRoles>} copyFactoryRoles copy factory roles\n   * @param {number} copyFactoryResourceSlots copy factory resource slots\n   * @return {Promise} promise resolving when account copy factory is enabled\n   */\n  async enableCopyFactoryApi(copyFactoryRoles: Array<CopyFactoryRoles>, copyFactoryResourceSlots: number) {\n    await this._metatraderAccountClient.enableCopyFactoryApi(this.id, copyFactoryRoles, copyFactoryResourceSlots);\n    await this.reload();\n  }\n\n  /**\n   * Enables MetaStats API for trading account.\n   * The account will be temporary stopped to perform this action.\n   * Note that this is a paid option\n   * @returns {Promise} promise resolving when account MetaStats API is enabled\n   */\n  async enableMetaStatsApi() {\n    await this._metatraderAccountClient.enableMetaStatsApi(this.id);\n    await this.reload();\n  }\n\n  /**\n   * Waits until API server has finished deployment and account reached the DEPLOYED state\n   * @param {number} timeoutInSeconds wait timeout in seconds, default is 5m\n   * @param {number} intervalInMilliseconds interval between account reloads while waiting for a change, default is 1s\n   * @return {Promise} promise which resolves when account is deployed\n   * @throws {TimeoutError} if account have not reached the DEPLOYED state within timeout allowed\n   */\n  async waitDeployed(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {\n    let startTime = Date.now();\n    await this.reload();\n    while (this.state !== 'DEPLOYED' && (startTime + timeoutInSeconds * 1000) > Date.now()) {\n      await this._delay(intervalInMilliseconds);\n      await this.reload();\n    }\n    if (this.state !== 'DEPLOYED') {\n      throw new TimeoutError('Timed out waiting for account ' + this.id + ' to be deployed');\n    }\n  }\n\n  /**\n   * Waits until API server has finished undeployment and account reached the UNDEPLOYED state\n   * @param {number} timeoutInSeconds wait timeout in seconds, default is 5m\n   * @param {number} intervalInMilliseconds interval between account reloads while waiting for a change, default is 1s\n   * @return {Promise} promise which resolves when account is deployed\n   * @throws {TimeoutError} if account have not reached the UNDEPLOYED state within timeout allowed\n   */\n  async waitUndeployed(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {\n    let startTime = Date.now();\n    await this.reload();\n    while (this.state !== 'UNDEPLOYED' && (startTime + timeoutInSeconds * 1000) > Date.now()) {\n      await this._delay(intervalInMilliseconds);\n      await this.reload();\n    }\n    if (this.state !== 'UNDEPLOYED') {\n      throw new TimeoutError('Timed out waiting for account ' + this.id + ' to be undeployed');\n    }\n  }\n\n  /**\n   * Waits until account has been deleted\n   * @param {number} timeoutInSeconds wait timeout in seconds, default is 5m\n   * @param {number} intervalInMilliseconds interval between account reloads while waiting for a change, default is 1s\n   * @return {Promise} promise which resolves when account is deleted\n   * @throws {TimeoutError} if account was not deleted within timeout allowed\n   */\n  async waitRemoved(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {\n    let startTime = Date.now();\n    try {\n      await this.reload();\n      while (startTime + timeoutInSeconds * 1000 > Date.now()) {\n        await this._delay(intervalInMilliseconds);\n        await this.reload();\n      }\n      throw new TimeoutError('Timed out waiting for account ' + this.id + ' to be deleted');\n    } catch (err) {\n      if (err.name === 'NotFoundError') {\n        return;\n      } else {\n        throw err;\n      }\n    }\n  }\n\n  /**\n   * Waits until API server has connected to the terminal and terminal has connected to the broker\n   * @param {number} timeoutInSeconds wait timeout in seconds, default is 5m\n   * @param {number} intervalInMilliseconds interval between account reloads while waiting for a change, default is 1s\n   * @return {Promise} promise which resolves when API server is connected to the broker\n   * @throws {TimeoutError} if account have not connected to the broker within timeout allowed\n   */\n  async waitConnected(timeoutInSeconds = 300, intervalInMilliseconds = 1000) {\n    const checkConnected = () => {\n      return [this.connectionStatus].concat(this.replicas.map(replica => \n        replica.connectionStatus)).includes('CONNECTED');\n    };\n\n    let startTime = Date.now();\n    await this.reload();\n    while (!checkConnected() && (startTime + timeoutInSeconds * 1000) > Date.now()) {\n      await this._delay(intervalInMilliseconds);\n      await this.reload();\n    }\n    if (!checkConnected()) {\n      throw new TimeoutError('Timed out waiting for account ' + this.id + ' to connect to the broker');\n    }\n  }\n\n  /**\n   * Connects to MetaApi. There is only one connection per account. Subsequent calls to this method will return the same connection.\n   * @param {HistoryStorage} historyStorage optional history storage\n   * @param {Date} [historyStartTime] history start time. Used for tests\n   * @return {StreamingMetaApiConnectionInstance} MetaApi connection instance\n   */\n  getStreamingConnection(historyStorage?: HistoryStorage, historyStartTime?: Date): StreamingMetaApiConnectionInstance {\n    if(this._metaApiWebsocketClient.region && this._metaApiWebsocketClient.region !== this.region) {\n      throw new ValidationError(\n        `Account ${this.id} is not on specified region ${this._metaApiWebsocketClient.region}`\n      );\n    }\n\n    return this._connectionRegistry.connectStreaming(this, historyStorage, historyStartTime);\n  }\n\n  /**\n   * Connects to MetaApi via RPC connection instance.\n   * @returns {RpcMetaApiConnectionInstance} MetaApi connection instance\n   */\n  getRPCConnection(): RpcMetaApiConnectionInstance {\n    if(this._metaApiWebsocketClient.region && this._metaApiWebsocketClient.region !== this.region) {\n      throw new ValidationError(\n        `Account ${this.id} is not on specified region ${this._metaApiWebsocketClient.region}`\n      );\n    }\n    return this._connectionRegistry.connectRpc(this);\n  }\n\n  /**\n   * Updates trading account. \n   * Please redeploy the trading account in order for updated settings to take effect\n   * @param {MetatraderAccountUpdateDto} account updated account information\n   * @return {Promise} promise resolving when account is updated\n   */\n  async update(account: MetatraderAccountUpdateDto) {\n    await this._metatraderAccountClient.updateAccount(this.id, account);\n    await this.reload();\n  }\n\n  /**\n   * Creates a trading account replica in a region different from trading account region and starts a cloud API server for it\n   * @param {NewMetaTraderAccountDto} account MetaTrader account data\n   * @return {Promise<MetatraderAccountReplica>} promise resolving with created MetaTrader account replica entity\n   */\n  async createReplica(account: NewMetaTraderAccountReplicaDto): Promise<MetatraderAccountReplica> {\n    await this._metatraderAccountClient.createAccountReplica(this.id, account);\n    await this.reload();\n    return this._replicas.find(r => r.region === account.region);\n  }\n\n  /**\n   * Retrieves expert advisor of current account\n   * @returns {Promise<ExpertAdvisor[]>} promise resolving with an array of expert advisor entities\n   */\n  async getExpertAdvisors(): Promise<ExpertAdvisor[]> {\n    this._checkExpertAdvisorAllowed();\n    let expertAdvisors = await this._expertAdvisorClient.getExpertAdvisors(this.id);\n    return expertAdvisors.map(e => new ExpertAdvisor(e, this.id, this._expertAdvisorClient));\n  }\n\n  /**\n   * Retrieves a expert advisor of current account by id\n   * @param {String} expertId expert advisor id\n   * @returns {Promise<ExpertAdvisor>} promise resolving with expert advisor entity\n   */\n  async getExpertAdvisor(expertId: string): Promise<ExpertAdvisor> {\n    this._checkExpertAdvisorAllowed();\n    let expertAdvisor = await this._expertAdvisorClient.getExpertAdvisor(this.id, expertId);\n    return new ExpertAdvisor(expertAdvisor, this.id, this._expertAdvisorClient);\n  }\n\n  /**\n   * Creates an expert advisor\n   * @param {string} expertId expert advisor id\n   * @param {NewExpertAdvisorDto} expert expert advisor data\n   * @returns {Promise<ExpertAdvisor>} promise resolving with expert advisor entity\n   */\n  async createExpertAdvisor(expertId: string, expert: NewExpertAdvisorDto): Promise<ExpertAdvisor> {\n    this._checkExpertAdvisorAllowed();\n    await this._expertAdvisorClient.updateExpertAdvisor(this.id, expertId, expert);\n    return this.getExpertAdvisor(expertId);\n  }\n\n  /**\n   * Returns historical candles for a specific symbol and timeframe from the MetaTrader account.\n   * See https://metaapi.cloud/docs/client/restApi/api/retrieveMarketData/readHistoricalCandles/\n   * @param {string} symbol symbol to retrieve candles for (e.g. a currency pair or an index)\n   * @param {string} timeframe defines the timeframe according to which the candles must be generated. Allowed values\n   * for MT5 are 1m, 2m, 3m, 4m, 5m, 6m, 10m, 12m, 15m, 20m, 30m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1d, 1w, 1mn. Allowed\n   * values for MT4 are 1m, 5m, 15m 30m, 1h, 4h, 1d, 1w, 1mn\n   * @param {Date} [startTime] time to start loading candles from. Note that candles are loaded in backwards direction, so\n   * this should be the latest time. Leave empty to request latest candles.\n   * @param {number} [limit] maximum number of candles to retrieve. Must be less or equal to 1000\n   * @return {Promise<Array<MetatraderCandle>>} promise resolving with historical candles downloaded\n   */\n  getHistoricalCandles(\n    symbol: string, timeframe: string, startTime?: Date, limit?: number\n  ): Promise<Array<MetatraderCandle>> {\n    return this._historicalMarketDataClient.getHistoricalCandles(this.id, this.region, symbol,\n      timeframe, startTime, limit);\n  }\n  \n  /**\n   * Returns historical ticks for a specific symbol from the MetaTrader account. This API is not supported by MT4\n   * accounts.\n   * See https://metaapi.cloud/docs/client/restApi/api/retrieveMarketData/readHistoricalTicks/\n   * @param {string} symbol symbol to retrieve ticks for (e.g. a currency pair or an index)\n   * @param {Date} [startTime] time to start loading ticks from. Note that candles are loaded in forward direction, so\n   * this should be the earliest time. Leave empty to request latest candles.\n   * @param {number} [offset] number of ticks to skip (you can use it to avoid requesting ticks from previous request\n   * twice)\n   * @param {number} [limit] maximum number of ticks to retrieve. Must be less or equal to 1000\n   * @return {Promise<Array<MetatraderTick>>} promise resolving with historical ticks downloaded\n   */\n  getHistoricalTicks(\n    symbol: string, startTime?: Date, offset?: number, limit?: number\n  ): Promise<Array<MetatraderTick>> {\n    return this._historicalMarketDataClient.getHistoricalTicks(this.id, this.region, symbol, startTime, offset, limit);\n  }\n\n  /**\n   * Generates trading account configuration link by account id.\n   * @param {number} [ttlInDays] Lifetime of the link in days. Default is 7.\n   * @return {Promise<ConfigurationLink>} promise resolving with configuration link\n   */\n  async createConfigurationLink(ttlInDays?: number): Promise<ConfigurationLink> {\n    const configurationLink = await this._metatraderAccountClient.createConfigurationLink(this.id, ttlInDays);\n    return configurationLink;\n  }\n\n  private _checkExpertAdvisorAllowed() {\n    if (this.version !== 4 || this.type !== 'cloud-g1') {\n      throw new ValidationError('Custom expert advisor is available only for MT4 G1 accounts');\n    }\n  }\n\n  private _delay(timeoutInMilliseconds) {\n    return new Promise(res => setTimeout(res, timeoutInMilliseconds));\n  }\n\n}\n\nnamespace MetatraderAccount {\n\n  /** Replica account IDs by region, including primary replica */\n  export type AccountsByRegion = {[region: string]: string};\n}\n\nexport default MetatraderAccount;\n"],"names":["HistoryDatabase","require","default","MetatraderAccount","id","_data","_id","state","magic","connectionStatus","quoteStreamingIntervalInSeconds","symbol","reliability","tags","metadata","resourceSlots","copyFactoryResourceSlots","region","createdAt","Date","name","manualTrades","slippage","provisioningProfileId","login","server","type","version","hash","baseCurrency","copyFactoryRoles","riskManagementApiEnabled","metastatsApiEnabled","allocateDedicatedIp","connections","primaryReplica","userId","primaryAccountId","accountReplicas","replicas","_replicas","accountRegions","regions","forEach","replica","reload","_metatraderAccountClient","getAccount","updatedReplicaData","map","createdReplicaRegions","filter","includes","updatedData","find","replicaData","updateData","push","MetatraderAccountReplica","remove","_connectionRegistry","closeAllInstances","deleteAccount","fileManager","getInstance","clear","_application","err","deploy","deployAccount","undeploy","undeployAccount","redeploy","redeployAccount","increaseReliability","enableRiskManagementApi","enableCopyFactoryApi","enableMetaStatsApi","waitDeployed","timeoutInSeconds","intervalInMilliseconds","startTime","now","_delay","TimeoutError","waitUndeployed","waitRemoved","waitConnected","checkConnected","concat","getStreamingConnection","historyStorage","historyStartTime","_metaApiWebsocketClient","ValidationError","connectStreaming","getRPCConnection","connectRpc","update","account","updateAccount","createReplica","createAccountReplica","r","getExpertAdvisors","_checkExpertAdvisorAllowed","expertAdvisors","_expertAdvisorClient","e","ExpertAdvisor","getExpertAdvisor","expertId","expertAdvisor","createExpertAdvisor","expert","updateExpertAdvisor","getHistoricalCandles","timeframe","limit","_historicalMarketDataClient","getHistoricalTicks","offset","createConfigurationLink","ttlInDays","configurationLink","timeoutInMilliseconds","Promise","res","setTimeout","constructor","data","metatraderAccountClient","metaApiWebsocketClient","connectionRegistry","expertAdvisorClient","historicalMarketDataClient","application"],"mappings":"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"}