metaapi.cloud-copyfactory-sdk
Version:
Javascript SDK for SDK for CopyFactory trade copying API. Can copy trades both between MetaTrader 5 (MT5) and MetaTrader 4 (MT4). (https://metaapi.cloud)
330 lines (329 loc) • 39.3 kB
JavaScript
;
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);
});
};
}
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;
}
import MetaApiClient from '../metaapi.client';
import SubscriberSignalClient from './subscriberSignal.client';
import StrategySignalClient from './strategySignal.client';
import StopoutListenerManager from './streaming/stopoutListenerManager';
import UserLogListenerManager from './streaming/userLogListenerManager';
export * from './trading.client.schemas';
let TradingClient = class TradingClient extends MetaApiClient {
/**
* Resynchronizes the account. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/resynchronize/
* @param {string} accountId account id
* @param {Array<string>} [strategyIds] array of strategy ids to recynchronize. Default is to synchronize all
* strategies
* @param {Array<string>} [positionIds] array of position ids to resynchronize. Default is to synchronize all
* positions
* @return {Promise} promise which resolves when resynchronization is scheduled
*/ resynchronize(accountId, strategyIds, positionIds) {
var _this = this;
return _async_to_generator(function*() {
if (_this._isNotJwtToken()) {
return _this._handleNoAccessError('resynchronize');
}
const opts = {
url: `/users/current/subscribers/${accountId}/resynchronize`,
method: 'POST',
headers: {
'auth-token': _this._token
},
params: {
strategyId: strategyIds,
positionId: positionIds
},
json: true
};
return _this._domainClient.requestCopyFactory(opts);
})();
}
/**
* Generates an instance of signal client for a subscriber
* @param {string} subscriberId subscriber account id
*/ getSubscriberSignalClient(subscriberId) {
var _this = this;
return _async_to_generator(function*() {
if (_this._isNotJwtToken()) {
return _this._handleNoAccessError('getSubscriberSignalClient');
}
let accountData = yield _this._domainClient.getAccountInfo(subscriberId);
const host = yield _this._domainClient.getSignalClientHost(accountData.regions);
return new SubscriberSignalClient(accountData.id, host, _this._domainClient);
})();
}
/**
* Generates an instance of signal client for a strategy
* @param {string} strategyId strategy id
*/ getStrategySignalClient(strategyId) {
var _this = this;
return _async_to_generator(function*() {
if (_this._isNotJwtToken()) {
return _this._handleNoAccessError('getStrategySignalClient');
}
const strategy = yield _this._configurationClient.getStrategy(strategyId);
const accountData = yield _this._domainClient.getAccountInfo(strategy.accountId);
const host = yield _this._domainClient.getSignalClientHost(accountData.regions);
return new StrategySignalClient(accountData.id, strategyId, host, _this._domainClient);
})();
}
/**
* Returns subscriber account stopouts. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/getStopOuts/
* @param {string} subscriberId subscriber id
* @return {Promise<Array<CopyFactoryStrategyStopout>>} promise which resolves with stopouts found
*/ getStopouts(subscriberId) {
var _this = this;
return _async_to_generator(function*() {
if (_this._isNotJwtToken()) {
return _this._handleNoAccessError('getStopouts');
}
const opts = {
url: `/users/current/subscribers/${subscriberId}/stopouts`,
method: 'GET',
headers: {
'auth-token': _this._token
},
json: true
};
return _this._domainClient.requestCopyFactory(opts);
})();
}
/**
* Resets subscription stopouts. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/resetSubscriptionStopOuts/
* @param {string} subscriberId subscriber id
* @param {string} strategyId strategy id
* @param {CopyFactoryStrategyStopoutReason} reason stopout reason to reset
* yearly-equity, monthly-equity, daily-equity
* @return {Promise} promise which resolves when the stopouts are reset
*/ resetSubscriptionStopouts(subscriberId, strategyId, reason) {
if (this._isNotJwtToken()) {
return this._handleNoAccessError('resetSubscriptionStopouts');
}
const opts = {
url: `/users/current/subscribers/${subscriberId}/subscription-strategies/` + `${strategyId}/stopouts/${reason}/reset`,
method: 'POST',
headers: {
'auth-token': this._token
},
json: true
};
return this._domainClient.requestCopyFactory(opts);
}
/**
* Resets subscriber stopouts. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/resetSubscriberStopOuts/
* @param {string} subscriberId subscriber id
* @param {CopyFactoryStrategyStopoutReason} reason stopout reason to reset
* yearly-equity, monthly-equity, daily-equity
* @return {Promise} promise which resolves when the stopouts are reset
*/ resetSubscriberStopouts(subscriberId, reason) {
if (this._isNotJwtToken()) {
return this._handleNoAccessError('resetSubscriberStopouts');
}
const opts = {
url: `/users/current/subscribers/${subscriberId}/stopouts/${reason}/reset`,
method: 'POST',
headers: {
'auth-token': this._token
},
json: true
};
return this._domainClient.requestCopyFactory(opts);
}
/**
* Returns copy trading user log for an account and time range. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/getUserLog/
* @param {string} subscriberId subscriber id
* @param {Date} [startTime] time to start loading data from
* @param {Date} [endTime] time to stop loading data at
* @param {string} [strategyId] strategy id filter
* @param {string} [positionId] position id filter
* @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level
* @param {Number} [offset] pagination offset. Default is 0
* @param {Number} [limit] pagination limit. Default is 1000
* @return {Promise<Array<CopyFactoryUserLogMessage>>} promise which resolves with log records found
*/ getUserLog(subscriberId, startTime, endTime, strategyId, positionId, level, offset = 0, limit = 1000) {
var _this = this;
return _async_to_generator(function*() {
if (_this._isNotJwtToken()) {
return _this._handleNoAccessError('getUserLog');
}
const opts = {
url: `/users/current/subscribers/${subscriberId}/user-log`,
method: 'GET',
params: {
startTime,
endTime,
strategyId,
positionId,
level,
offset,
limit
},
headers: {
'auth-token': _this._token
},
json: true
};
let result = yield _this._domainClient.requestCopyFactory(opts, true);
if (result) {
result.map((r)=>r.time = new Date(r.time));
}
return result;
})();
}
/**
* Returns event log for CopyFactory strategy, sorted in reverse chronological order. See
* https://metaapi.cloud/docs/copyfactory/restApi/api/trading/getStrategyLog/
* @param {string} strategyId strategy id to retrieve log for
* @param {Date} [startTime] time to start loading data from
* @param {Date} [endTime] time to stop loading data at
* @param {string} [positionId] position id filter
* @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level
* @param {Number} [offset] pagination offset. Default is 0
* @param {Number} [limit] pagination limit. Default is 1000
* @return {Promise<Array<CopyFactoryUserLogMessage>>} promise which resolves with log records found
*/ getStrategyLog(strategyId, startTime, endTime, positionId, level, offset = 0, limit = 1000) {
var _this = this;
return _async_to_generator(function*() {
if (_this._isNotJwtToken()) {
return _this._handleNoAccessError('getStrategyLog');
}
const opts = {
url: `/users/current/strategies/${strategyId}/user-log`,
method: 'GET',
params: {
startTime,
endTime,
positionId,
level,
offset,
limit
},
headers: {
'auth-token': _this._token
},
json: true
};
let result = yield _this._domainClient.requestCopyFactory(opts, true);
if (result) {
result.map((r)=>r.time = new Date(r.time));
}
return result;
})();
}
/**
* Adds a stopout listener and creates a job to make requests
* @param {StopoutListener} listener stopout listener
* @param {string} [accountId] account id
* @param {string} [strategyId] strategy id
* @param {Number} [sequenceNumber] sequence number
* @return {string} listener id
*/ addStopoutListener(listener, accountId, strategyId, sequenceNumber) {
return this._stopoutListenerManager.addStopoutListener(listener, accountId, strategyId, sequenceNumber);
}
/**
* Removes stopout listener and cancels the event stream
* @param {string} listenerId stopout listener id
*/ removeStopoutListener(listenerId) {
this._stopoutListenerManager.removeStopoutListener(listenerId);
}
/**
* Adds a strategy log listener and creates a job to make requests
* @param {UserLogListener} listener user log listener
* @param {string} strategyId strategy id
* @param {Date} [startTime] log search start time
* @param {string} [positionId] position id filter
* @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level
* @param {Number} [limit] log pagination limit
* @return {string} listener id
*/ addStrategyLogListener(listener, strategyId, startTime, positionId, level, limit) {
return this._userLogListenerManager.addStrategyLogListener(listener, strategyId, startTime, positionId, level, limit);
}
/**
* Removes strategy log listener and cancels the event stream
* @param {string} listenerId strategy log listener id
*/ removeStrategyLogListener(listenerId) {
this._userLogListenerManager.removeStrategyLogListener(listenerId);
}
/**
* Adds a subscriber log listener and creates a job to make requests
* @param {UserLogListener} listener user log listener
* @param {string} subscriberId subscriber id
* @param {Date} [startTime] log search start time
* @param {string} [strategyId] strategy id filter
* @param {string} [positionId] position id filter
* @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level
* @param {Number} [limit] log pagination limit
* @return {string} listener id
*/ addSubscriberLogListener(listener, subscriberId, startTime, strategyId, positionId, level, limit) {
return this._userLogListenerManager.addSubscriberLogListener(listener, subscriberId, startTime, strategyId, positionId, level, limit);
}
/**
* Removes subscriber log listener and cancels the event stream
* @param {string} listenerId subscriber log listener id
*/ removeSubscriberLogListener(listenerId) {
this._userLogListenerManager.removeSubscriberLogListener(listenerId);
}
/**
* Constructs CopyFactory trading API client instance
* @param {DomainClient} domainClient domain client
* @param {ConfigurationClient} configurationClient configuration client
*/ constructor(domainClient, configurationClient){
super(domainClient);
_define_property(this, "_configurationClient", void 0);
_define_property(this, "_stopoutListenerManager", void 0);
_define_property(this, "_userLogListenerManager", void 0);
this._domainClient = domainClient;
this._configurationClient = configurationClient;
this._stopoutListenerManager = new StopoutListenerManager(domainClient);
this._userLogListenerManager = new UserLogListenerManager(domainClient);
}
};
/**
* metaapi.cloud CopyFactory trading API (trade copying trading API) client (see
* https://metaapi.cloud/docs/copyfactory/)
*/ export { TradingClient as default };
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport MetaApiClient from '../metaapi.client';\nimport SubscriberSignalClient from './subscriberSignal.client';\nimport StrategySignalClient from './strategySignal.client';\nimport StopoutListenerManager from './streaming/stopoutListenerManager';\nimport UserLogListenerManager from './streaming/userLogListenerManager';\nimport ConfigurationClient from './configuration.client';\nimport DomainClient from '../domain.client';\nimport StopoutListener from './streaming/stopoutListener';\nimport UserLogListener from './streaming/userLogListener';\nimport {\n  CopyFactoryStrategyStopout, CopyFactoryStrategyStopoutReason, CopyFactoryUserLogMessage\n} from './trading.client.schemas';\n\nexport * from './trading.client.schemas';\n\n/**\n * metaapi.cloud CopyFactory trading API (trade copying trading API) client (see\n * https://metaapi.cloud/docs/copyfactory/)\n */\nexport default class TradingClient extends MetaApiClient {\n  \n  private _configurationClient: ConfigurationClient;\n  private _stopoutListenerManager: StopoutListenerManager;\n  private _userLogListenerManager: UserLogListenerManager;\n\n  /**\n   * Constructs CopyFactory trading API client instance\n   * @param {DomainClient} domainClient domain client\n   * @param {ConfigurationClient} configurationClient configuration client\n   */\n  constructor(domainClient: DomainClient, configurationClient: ConfigurationClient) {\n    super(domainClient);\n    this._domainClient = domainClient;\n    this._configurationClient = configurationClient;\n    this._stopoutListenerManager = new StopoutListenerManager(domainClient);\n    this._userLogListenerManager = new UserLogListenerManager(domainClient);\n  }\n\n  /**\n   * Resynchronizes the account. See\n   * https://metaapi.cloud/docs/copyfactory/restApi/api/trading/resynchronize/\n   * @param {string} accountId account id\n   * @param {Array<string>} [strategyIds] array of strategy ids to recynchronize. Default is to synchronize all\n   * strategies\n   * @param {Array<string>} [positionIds] array of position ids to resynchronize. Default is to synchronize all\n   * positions\n   * @return {Promise} promise which resolves when resynchronization is scheduled\n   */\n  async resynchronize(accountId: string, strategyIds?: Array<string>, positionIds?: Array<string>): Promise<any> {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('resynchronize');\n    }\n    const opts = {\n      url: `/users/current/subscribers/${accountId}/resynchronize`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      params: {\n        strategyId: strategyIds,\n        positionId: positionIds\n      },\n      json: true\n    };\n    return this._domainClient.requestCopyFactory(opts);\n  }\n\n  /**\n   * Generates an instance of signal client for a subscriber\n   * @param {string} subscriberId subscriber account id\n   */\n  async getSubscriberSignalClient(subscriberId: string): Promise<SubscriberSignalClient> {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('getSubscriberSignalClient');\n    }\n\n    let accountData = await this._domainClient.getAccountInfo(subscriberId);\n    const host = await this._domainClient.getSignalClientHost(accountData.regions);\n    return new SubscriberSignalClient(accountData.id, host, this._domainClient);\n  }\n\n  /**\n   * Generates an instance of signal client for a strategy\n   * @param {string} strategyId strategy id\n   */\n  async getStrategySignalClient(strategyId: string): Promise<StrategySignalClient> {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('getStrategySignalClient');\n    }\n\n    const strategy = await this._configurationClient.getStrategy(strategyId);\n    const accountData = await this._domainClient.getAccountInfo(strategy.accountId);\n    const host = await this._domainClient.getSignalClientHost(accountData.regions);\n    return new StrategySignalClient(accountData.id, strategyId, host, this._domainClient);\n  }\n\n  /**\n   * Returns subscriber account stopouts. See\n   * https://metaapi.cloud/docs/copyfactory/restApi/api/trading/getStopOuts/\n   * @param {string} subscriberId subscriber id\n   * @return {Promise<Array<CopyFactoryStrategyStopout>>} promise which resolves with stopouts found\n   */\n  async getStopouts(subscriberId: string): Promise<Array<CopyFactoryStrategyStopout>> {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('getStopouts');\n    }\n    const opts = {\n      url: `/users/current/subscribers/${subscriberId}/stopouts`,\n      method: 'GET',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._domainClient.requestCopyFactory(opts);\n  }\n\n  /**\n   * Resets subscription stopouts. See\n   * https://metaapi.cloud/docs/copyfactory/restApi/api/trading/resetSubscriptionStopOuts/\n   * @param {string} subscriberId subscriber id\n   * @param {string} strategyId strategy id\n   * @param {CopyFactoryStrategyStopoutReason} reason stopout reason to reset\n   * yearly-equity, monthly-equity, daily-equity\n   * @return {Promise} promise which resolves when the stopouts are reset\n   */\n  resetSubscriptionStopouts(\n    subscriberId: string, strategyId: string, reason: CopyFactoryStrategyStopoutReason\n  ): Promise<any> {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('resetSubscriptionStopouts');\n    }\n    const opts = {\n      url: `/users/current/subscribers/${subscriberId}/subscription-strategies/` +\n        `${strategyId}/stopouts/${reason}/reset`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._domainClient.requestCopyFactory(opts);\n  }\n\n  /**\n   * Resets subscriber stopouts. See\n   * https://metaapi.cloud/docs/copyfactory/restApi/api/trading/resetSubscriberStopOuts/\n   * @param {string} subscriberId subscriber id\n   * @param {CopyFactoryStrategyStopoutReason} reason stopout reason to reset\n   * yearly-equity, monthly-equity, daily-equity\n   * @return {Promise} promise which resolves when the stopouts are reset\n   */\n  resetSubscriberStopouts(subscriberId: string, reason: CopyFactoryStrategyStopoutReason): Promise<any> {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('resetSubscriberStopouts');\n    }\n    const opts = {\n      url: `/users/current/subscribers/${subscriberId}/stopouts/${reason}/reset`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._domainClient.requestCopyFactory(opts);\n  }\n\n  /**\n   * Returns copy trading user log for an account and time range. See\n   * https://metaapi.cloud/docs/copyfactory/restApi/api/trading/getUserLog/\n   * @param {string} subscriberId subscriber id\n   * @param {Date} [startTime] time to start loading data from\n   * @param {Date} [endTime] time to stop loading data at\n   * @param {string} [strategyId] strategy id filter\n   * @param {string} [positionId] position id filter\n   * @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level\n   * @param {Number} [offset] pagination offset. Default is 0\n   * @param {Number} [limit] pagination limit. Default is 1000\n   * @return {Promise<Array<CopyFactoryUserLogMessage>>} promise which resolves with log records found\n   */\n  async getUserLog(\n    subscriberId: string, startTime?: Date, endTime?: Date, strategyId?: string, positionId?: string,\n    level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', offset = 0, limit = 1000\n  ): Promise<Array<CopyFactoryUserLogMessage>> {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('getUserLog');\n    }\n    const opts = {\n      url: `/users/current/subscribers/${subscriberId}/user-log`,\n      method: 'GET',\n      params: {\n        startTime,\n        endTime,\n        strategyId, \n        positionId, \n        level,\n        offset,\n        limit\n      },\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    let result = await this._domainClient.requestCopyFactory(opts, true);\n    if (result) {\n      result.map(r => r.time = new Date(r.time));\n    }\n    return result;\n  }\n\n  /**\n   * Returns event log for CopyFactory strategy, sorted in reverse chronological order. See\n   * https://metaapi.cloud/docs/copyfactory/restApi/api/trading/getStrategyLog/ \n   * @param {string} strategyId strategy id to retrieve log for\n   * @param {Date} [startTime] time to start loading data from\n   * @param {Date} [endTime] time to stop loading data at\n   * @param {string} [positionId] position id filter\n   * @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level\n   * @param {Number} [offset] pagination offset. Default is 0\n   * @param {Number} [limit] pagination limit. Default is 1000\n   * @return {Promise<Array<CopyFactoryUserLogMessage>>} promise which resolves with log records found\n   */\n  async getStrategyLog(\n    strategyId: string, startTime?: Date, endTime?: Date, positionId?: string,\n    level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', offset = 0, limit = 1000\n  ): Promise<Array<CopyFactoryUserLogMessage>> {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('getStrategyLog');\n    }\n    const opts = {\n      url: `/users/current/strategies/${strategyId}/user-log`,\n      method: 'GET',\n      params: {\n        startTime,\n        endTime,\n        positionId,\n        level,\n        offset,\n        limit\n      },\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    let result = await this._domainClient.requestCopyFactory(opts, true);\n    if (result) {\n      result.map(r => r.time = new Date(r.time));\n    }\n    return result;\n  }\n\n  /**\n   * Adds a stopout listener and creates a job to make requests\n   * @param {StopoutListener} listener stopout listener\n   * @param {string} [accountId] account id\n   * @param {string} [strategyId] strategy id\n   * @param {Number} [sequenceNumber] sequence number\n   * @return {string} listener id\n   */\n  addStopoutListener(\n    listener: StopoutListener, accountId?: string, strategyId?: string, sequenceNumber?: number\n  ): string {\n    return this._stopoutListenerManager.addStopoutListener(listener, accountId, strategyId, sequenceNumber);\n  }\n\n  /**\n   * Removes stopout listener and cancels the event stream\n   * @param {string} listenerId stopout listener id\n   */\n  removeStopoutListener(listenerId: string): void {\n    this._stopoutListenerManager.removeStopoutListener(listenerId);\n  }\n\n  /**\n   * Adds a strategy log listener and creates a job to make requests\n   * @param {UserLogListener} listener user log listener\n   * @param {string} strategyId strategy id\n   * @param {Date} [startTime] log search start time\n   * @param {string} [positionId] position id filter\n   * @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level\n   * @param {Number} [limit] log pagination limit\n   * @return {string} listener id\n   */\n  addStrategyLogListener(\n    listener: UserLogListener, strategyId: string, startTime?: Date, positionId?: string,\n    level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', limit?: number\n  ): string {\n    return this._userLogListenerManager.addStrategyLogListener(\n      listener, \n      strategyId, \n      startTime, \n      positionId, \n      level, \n      limit\n    );\n  }\n\n  /**\n   * Removes strategy log listener and cancels the event stream\n   * @param {string} listenerId strategy log listener id\n   */\n  removeStrategyLogListener(listenerId: string): void {\n    this._userLogListenerManager.removeStrategyLogListener(listenerId);\n  }\n\n  /**\n   * Adds a subscriber log listener and creates a job to make requests\n   * @param {UserLogListener} listener user log listener\n   * @param {string} subscriberId subscriber id\n   * @param {Date} [startTime] log search start time\n   * @param {string} [strategyId] strategy id filter\n   * @param {string} [positionId] position id filter\n   * @param {'DEBUG'|'INFO'|'WARN'|'ERROR'} [level] minimum severity level\n   * @param {Number} [limit] log pagination limit\n   * @return {string} listener id\n   */\n  addSubscriberLogListener(\n    listener: UserLogListener, subscriberId: string, startTime?: Date, strategyId?: string, positionId?: string,\n    level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', limit?: number\n  ): string {\n    return this._userLogListenerManager.addSubscriberLogListener(\n      listener, \n      subscriberId, \n      startTime, \n      strategyId, \n      positionId, \n      level, \n      limit\n    );\n  }\n\n  /**\n   * Removes subscriber log listener and cancels the event stream\n   * @param {string} listenerId subscriber log listener id\n   */\n  removeSubscriberLogListener(listenerId: string): void {\n    this._userLogListenerManager.removeSubscriberLogListener(listenerId);\n  }\n}\n"],"names":["MetaApiClient","SubscriberSignalClient","StrategySignalClient","StopoutListenerManager","UserLogListenerManager","TradingClient","resynchronize","accountId","strategyIds","positionIds","_isNotJwtToken","_handleNoAccessError","opts","url","method","headers","_token","params","strategyId","positionId","json","_domainClient","requestCopyFactory","getSubscriberSignalClient","subscriberId","accountData","getAccountInfo","host","getSignalClientHost","regions","id","getStrategySignalClient","strategy","_configurationClient","getStrategy","getStopouts","resetSubscriptionStopouts","reason","resetSubscriberStopouts","getUserLog","startTime","endTime","level","offset","limit","result","map","r","time","Date","getStrategyLog","addStopoutListener","listener","sequenceNumber","_stopoutListenerManager","removeStopoutListener","listenerId","addStrategyLogListener","_userLogListenerManager","removeStrategyLogListener","addSubscriberLogListener","removeSubscriberLogListener","constructor","domainClient","configurationClient"],"mappings":"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"}