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)
296 lines (295 loc) • 38 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, /**
* metaapi.cloud CopyFactory trading API (trade copying trading API) client (see
* https://metaapi.cloud/docs/copyfactory/)
*/ "default", {
enumerable: true,
get: function() {
return TradingClient;
}
});
const _metaapiclient = /*#__PURE__*/ _interop_require_default(require("../metaapi.client"));
const _subscriberSignalclient = /*#__PURE__*/ _interop_require_default(require("./subscriberSignal.client"));
const _strategySignalclient = /*#__PURE__*/ _interop_require_default(require("./strategySignal.client"));
const _stopoutListenerManager = /*#__PURE__*/ _interop_require_default(require("./streaming/stopoutListenerManager"));
const _userLogListenerManager = /*#__PURE__*/ _interop_require_default(require("./streaming/userLogListenerManager"));
_export_star(require("./trading.client.schemas"), exports);
function _export_star(from, to) {
Object.keys(from).forEach(function(k) {
if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
Object.defineProperty(to, k, {
enumerable: true,
get: function() {
return from[k];
}
});
}
});
return from;
}
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
let TradingClient = class TradingClient extends _metaapiclient.default {
_configurationClient;
_stopoutListenerManager;
_userLogListenerManager;
/**
* Constructs CopyFactory trading API client instance
* @param {DomainClient} domainClient domain client
* @param {ConfigurationClient} configurationClient configuration client
*/ constructor(domainClient, configurationClient){
super(domainClient);
this._domainClient = domainClient;
this._configurationClient = configurationClient;
this._stopoutListenerManager = new _stopoutListenerManager.default(domainClient);
this._userLogListenerManager = new _userLogListenerManager.default(domainClient);
}
/**
* 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
*/ async resynchronize(accountId, strategyIds, positionIds) {
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
*/ async getSubscriberSignalClient(subscriberId) {
if (this._isNotJwtToken()) {
return this._handleNoAccessError("getSubscriberSignalClient");
}
let accountData = await this._domainClient.getAccountInfo(subscriberId);
const host = await this._domainClient.getSignalClientHost(accountData.regions);
return new _subscriberSignalclient.default(accountData.id, host, this._domainClient);
}
/**
* Generates an instance of signal client for a strategy
* @param {string} strategyId strategy id
*/ async getStrategySignalClient(strategyId) {
if (this._isNotJwtToken()) {
return this._handleNoAccessError("getStrategySignalClient");
}
const strategy = await this._configurationClient.getStrategy(strategyId);
const accountData = await this._domainClient.getAccountInfo(strategy.accountId);
const host = await this._domainClient.getSignalClientHost(accountData.regions);
return new _strategySignalclient.default(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
*/ async getStopouts(subscriberId) {
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
*/ async getUserLog(subscriberId, startTime, endTime, strategyId, positionId, level, offset = 0, limit = 1000) {
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 = await 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
*/ async getStrategyLog(strategyId, startTime, endTime, positionId, level, offset = 0, limit = 1000) {
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 = await 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);
}
};
//# 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":["TradingClient","MetaApiClient","_configurationClient","_stopoutListenerManager","_userLogListenerManager","constructor","domainClient","configurationClient","_domainClient","StopoutListenerManager","UserLogListenerManager","resynchronize","accountId","strategyIds","positionIds","_isNotJwtToken","_handleNoAccessError","opts","url","method","headers","_token","params","strategyId","positionId","json","requestCopyFactory","getSubscriberSignalClient","subscriberId","accountData","getAccountInfo","host","getSignalClientHost","regions","SubscriberSignalClient","id","getStrategySignalClient","strategy","getStrategy","StrategySignalClient","getStopouts","resetSubscriptionStopouts","reason","resetSubscriberStopouts","getUserLog","startTime","endTime","level","offset","limit","result","map","r","time","Date","getStrategyLog","addStopoutListener","listener","sequenceNumber","removeStopoutListener","listenerId","addStrategyLogListener","removeStrategyLogListener","addSubscriberLogListener","removeSubscriberLogListener"],"mappings":"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"}