"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "default", {
    enumerable: true,
    get: function() {
        return MetatraderAccountClient;
    }
});
const _metaApiclient = /*#__PURE__*/ _interop_require_default(require("../metaApi.client"));
const _randomstring = /*#__PURE__*/ _interop_require_default(require("randomstring"));
function _interop_require_default(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
let MetatraderAccountClient = class MetatraderAccountClient extends _metaApiclient.default {
    /**
   * Metatrader account replica model
   * @typedef {Object} MetatraderAccountReplicaDto
   * @property {string} _id Unique account replica id
   * @property {State} state Current account replica state
   * @property {number} magic Magic value the trades should be performed using
   * @property {ConnectionStatus} connectionStatus Connection status of the MetaTrader terminal to the application
   * @property {string} quoteStreamingIntervalInSeconds Quote streaming interval in seconds. Set to 0 in order to 
   * receive quotes on each tick. Intervals less than 2.5 seconds are supported only for G2
   * @property {string} [symbol] Any symbol provided by broker (required for G1 only)
   * @property {Reliability} reliability Used to increase the reliability of the account replica. High is a recommended value
   * for production environment
   * @property {Array<string>} tags User-defined account replica tags
   * @property {Object} [metadata] Extra information which can be stored together with your account replica. 
   * Total length of this field after serializing it to JSON is limited to 1024 characters
   * @property {number} resourceSlots Number of resource slots to allocate to account replica. 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 CooyFactory 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.
   * @property {number} copyFactoryResourceSlots Number of CopyFactory 2 resource slots to allocate to account replica.
   * 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.
   * @property {string} region Region id to deploy account replica at. One of returned by the /users/current/regions endpoint
   * @property {string} createdAt The time account replica was created at, in ISO format
   * @property {MetatraderAccountDto} primaryAccount Primary account
   */ /**
   * MetaTrader account model
   * @typedef {Object} MetatraderAccountDto
   * @property {string} _id Unique account id
   * @property {State} state Current account state
   * @property {number} magic Magic value the trades should be performed using
   * @property {ConnectionStatus} connectionStatus Connection status of the MetaTrader terminal to the application
   * @property {string} quoteStreamingIntervalInSeconds Quote streaming interval in seconds. Set to 0 in order to 
   * receive quotes on each tick. Intervals less than 2.5 seconds are supported only for G2
   * @property {string} [symbol] Any symbol provided by broker (required for G1 only)
   * @property {Reliability} reliability Used to increase the reliability of the account. High is a recommended value
   * for production environment
   * @property {Array<string>} tags User-defined account tags
   * @property {Object} [metadata] Extra information which can be stored together with your account. 
   * Total length of this field after serializing it to JSON is limited to 1024 characters
   * @property {number} resourceSlots 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 CooyFactory 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.
   * @property {number} copyFactoryResourceSlots 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.
   * @property {string} region Region id to deploy account at. One of returned by the /users/current/regions endpoint
   * @property {string} createdAt The time account was created at, in ISO format
   * @property {string} name Human-readable account name
   * @property {boolean} manualTrades Flag indicating if trades should be placed as manual trades. Supported on G2 only
   * @property {number} [slippage] Default trade slippage in points. Should be greater or equal to zero. If not
   * specified, system internal setting will be used which we believe is reasonable for most cases
   * @property {string} [provisioningProfileId] Id of the provisioning profile that was used as the basis for 
   * creating this account
   * @property {string} [login] MetaTrader account login
   * @property {string} server MetaTrader server name to connect to 
   * @property {Type} type Account type. Executing accounts as cloud-g2 is faster and cheaper
   * @property {Version} version MetaTrader version
   * @property {number} hash Hash-code of the account
   * @property {string} baseCurrency 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.
   * @property {Array<CopyFactoryRoles>} copyFactoryRoles Account roles for CopyFactory2 application
   * @property {boolean} riskManagementApiEnabled Flag indicating that risk management API is enabled on
   * account
   * @property {boolean} metastatsApiEnabled Flag indicating that MetaStats API is enabled on account
   * @property {Array<AccountConnection>} connections Active account connections
   * @property {boolean} primaryReplica Flag indicating that account is primary
   * @property {string} userId User id
   * @property {string} [primaryAccountId] Primary account id. Only replicas can have this field
   * @property {Array<MetatraderAccountReplicaDto>} accountReplicas MetaTrader account replicas
   */ /**
   * MetaTrader account list model
   * @typedef {Object} MetatraderAccountListDto
   * @property {number} count MetaTrader accounts count
   * @property {Array<MetatraderAccountDto>} items MetaTrader accounts list
   */ /**
   * Account connection
   * @typedef {Object} AccountConnection
   * @property {string} region Region the account is connected at
   * @property {string} zone Availability zone the account is connected at
   * @property {string} application Application the account is connected to, one of `MetaApi`, `CopyFactory subscriber`,
   * `CopyFactory provider`, `CopyFactory history import`, `Risk management`
   */ /**
   * MT version
   * @typedef {4 | 5} Version
   */ /**
   * MT platform
   * @typedef {'mt4' | 'mt5'} Platform
   */ /**
   * Account type
   * @typedef {'cloud-g1' | 'cloud-g2'} Type
   */ /**
   * Account state
   * @typedef {'CREATED' | 'DEPLOYING' | 'DEPLOYED' | 'DEPLOY_FAILED' | 'UNDEPLOYING' | 'UNDEPLOYED' |
   * 'UNDEPLOY_FAILED' | 'DELETING' | 'DELETE_FAILED' | 'REDEPLOY_FAILED' | 'DRAFT'} State
   */ /**
   * Account connection status
   * @typedef {'CONNECTED' | 'DISCONNECTED' | 'DISCONNECTED_FROM_BROKER'} ConnectionStatus
   */ /**
   * Account reliability
   * @typedef {'high' | 'regular'} Reliability
   */ /**
   * CopyFactory roles
   * @typedef {'SUBSCRIBER' | 'PROVIDER'} CopyFactoryRoles
   */ /**
   * Sort order
   * @typedef {'asc' | 'desc'} SortOrder
   */ /**
   * Get accounts api version
   * @typedef {'1' | '2'} GetAccountsApiVersion
   */ /**
   * @typedef {Object} AccountsFilter
   * @property {number} [offset] Search offset (defaults to 0) (must be greater or equal to 0)
   * @property {number} [limit] Search limit (defaults to 1000) 
   * (must be greater or equal to 1 and less or equal to 1000)
   * @property {Array<Version> | Version} [version] MT version
   * @property {Array<Type> | Type} [type] Account type
   * @property {Array<State> | State} [state] Account state
   * @property {Array<ConnectionStatus> | ConnectionStatus} [connectionStatus] Connection status
   * @property {string} [query] Searches over _id, name, server and login to match query
   * @property {string} [provisioningProfileId] Provisioning profile id
   * @property {SortOrder} [sortOrder] Sort order for stateChangedAt field, default is no order
   * @property {Array<string> | string} [region] Available region
   * @property {Array<CopyFactoryRoles> | CopyFactoryRoles} [copyFactoryRoles] Account roles for CopyFactory2 API
   */ /**
   * Returns trading accounts belonging to the current user (see https://metaapi.cloud/docs/provisioning/api/account/readAccounts/)
   * Method is accessible only with API access token
   * @param {AccountsFilter} [accountsFilter] optional filter
   * @param {GetAccountsApiVersion} [apiVersion] api version to use
   * @return {Promise<Array<MetatraderAccountDto> | MetatraderAccountListDto>} promise resolving with MetaTrader accounts found
   */ getAccounts(accountsFilter = {}, apiVersion) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("getAccounts");
        }
        const opts = {
            url: `${this._host}/users/current/accounts`,
            method: "GET",
            params: accountsFilter,
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        if (apiVersion) {
            opts.headers["api-version"] = apiVersion;
        }
        return this._httpClient.request(opts, "getAccounts");
    }
    /**
   * Returns trading account by id (see https://metaapi.cloud/docs/provisioning/api/account/readAccount/)
   * Method is accessible only with API access token
   * @param {string} id MetaTrader account id
   * @return {Promise<MetatraderAccountDto>} promise resolving with MetaTrader account found
   */ getAccount(id) {
        const opts = {
            url: `${this._host}/users/current/accounts/${id}`,
            method: "GET",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "getAccount");
    }
    /**
   * Returns trading account replica by trading account id and replica id (see 
   * https://metaapi.cloud/docs/provisioning/api/accountReplica/readAccountReplica/)
   * Method is accessible only with API access token
   * @param {string} accountId MetaTrader primary account id
   * @param {string} replicaId MetaTrader account replica id
   * @return {Promise<MetatraderAccountReplicaDto>} promise resolving with MetaTrader account replica found
   */ getAccountReplica(accountId, replicaId) {
        const opts = {
            url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}`,
            method: "GET",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "getAccountReplica");
    }
    /**
   * Returns replicas for a trading account (see 
   * https://metaapi.cloud/docs/provisioning/api/accountReplica/readAccountReplicas/)
   * Method is accessible only with API access token
   * @param {string} accountId Primary account id
   * @return {Promise<Array<MetatraderAccountReplicaDto>>} promise resolving with MetaTrader account replicas found
   */ getAccountReplicas(accountId) {
        const opts = {
            url: `${this._host}/users/current/accounts/${accountId}/replicas`,
            method: "GET",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "getAccountReplicas");
    }
    /**
   * MetaTrader account id model
   * @typedef {Object} MetatraderAccountIdDto
   * @property {string} id MetaTrader account unique identifier
   * @property {string} state State of the account. Possible values are 'UNDEPLOYED', 'DEPLOYED', 'DRAFT'
   */ /**
   * Adds a trading account and starts a cloud API server for the trading account (see 
   * https://metaapi.cloud/docs/provisioning/api/account/createAccount/).
   * It can take some time for the API server and trading terminal to start and connect to broker.
   * You can use the `connectionStatus` replica field to monitor the current status of the trading account.
   * Method is accessible only with API access token
   * @param {NewMetatraderAccountDto} account MetaTrader account data
   * @return {Promise<MetatraderAccountIdDto>} promise resolving with an id and state of the MetaTrader account created
   */ createAccount(account) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("createAccount");
        }
        const opts = {
            url: `${this._host}/users/current/accounts`,
            method: "POST",
            headers: {
                "auth-token": this._token,
                "transaction-id": _randomstring.default.generate(32)
            },
            json: true,
            data: account
        };
        return this._httpClient.request(opts, "createAccount");
    }
    /**
   * New MetaTrader account replica model
   * @typedef {Object} NewMetaTraderAccountReplicaDto
   * @property {string} [symbol] Any MetaTrader symbol your broker provides historical market data for. 
   * This value should be specified for G1 accounts only and only in case your MT account fails to connect to broker.
   * @property {number} magic Magic value the trades should be performed using.
   * When manualTrades field is set to true, magic value must be 0
   * @property {string} [quoteStreamingIntervalInSeconds] Quote streaming interval in seconds. Set to 0 in order to 
   * receive quotes on each tick. Default value is 2.5 seconds. Intervals less than 2.5 seconds are supported only for G2
   * @property {Array<string>} [tags] User-defined account replica tags
   * @property {Object} [metadata] Extra information which can be stored together with your account replica. 
   * Total length of this field after serializing it to JSON is limited to 1024 characters
   * @property {Reliability} [reliability] Used to increase the reliability of the account replica. High is a recommended value 
   * for production environment. Default value is high
   * @property {number} [resourceSlots] Number of resource slots to allocate to account replica. 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 CooyFactory 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. Default is 1.
   * @property {number} [copyFactoryResourceSlots] Number of CopyFactory 2 resource slots to allocate to account replica.
   * 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.
   * Default is 1.
   * @property {string} region Region id to deploy account replica at. One of returned by the /users/current/regions endpoint
   */ /**
   * Creates a trading account replica in a region different from trading account region and starts a cloud API server for it
   * (see https://metaapi.cloud/docs/provisioning/api/accountReplica/createAccountReplica/).
   * It can take some time for the API server and trading terminal to start and connect to broker.
   * You can use the `connectionStatus` replica field to monitor the current status of the replica.
   * Method is accessible only with API access token
   * @param {string} accountId primary account id
   * @param {NewMetaTraderAccountReplicaDto} account MetaTrader account data
   * @return {Promise<MetatraderAccountIdDto>} promise resolving with an id and state of the MetaTrader account replica created
   */ createAccountReplica(accountId, account) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("createAccountReplica");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${accountId}/replicas`,
            method: "POST",
            headers: {
                "auth-token": this._token,
                "transaction-id": _randomstring.default.generate(32)
            },
            json: true,
            data: account
        };
        return this._httpClient.request(opts, "createAccountReplica");
    }
    /**
   * Starts API server and trading terminal for trading account.
   * This request will be ignored if the account is already deployed.
   * (see https://metaapi.cloud/docs/provisioning/api/account/deployAccount/)
   * Method is accessible only with API access token
   * @param {string} id MetaTrader account id
   * @return {Promise} promise resolving when MetaTrader account is scheduled for deployment
   */ deployAccount(id) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("deployAccount");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${id}/deploy`,
            method: "POST",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "deployAccount");
    }
    /**
   * Starts API server and trading terminal for trading account replica.
   * This request will be ignored if the replica is already deployed
   * (see https://metaapi.cloud/docs/provisioning/api/accountReplica/deployAccountReplica/)
   * Method is accessible only with API access token
   * @param {string} accountId MetaTrader account id
   * @param {string} replicaId MetaTrader account replica id
   * @return {Promise} promise resolving when MetaTrader account replica is scheduled for deployment
   */ deployAccountReplica(accountId, replicaId) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("deployAccountReplica");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}/deploy`,
            method: "POST",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "deployAccountReplica");
    }
    /**
   * Stops API server and trading terminal for trading account.
   * This request will be ignored if trading account is already undeployed
   * (see https://metaapi.cloud/docs/provisioning/api/account/undeployAccount/)
   * Method is accessible only with API access token
   * @param {string} id MetaTrader account id
   * @return {Promise} promise resolving when MetaTrader account is scheduled for undeployment
   */ undeployAccount(id) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("undeployAccount");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${id}/undeploy`,
            method: "POST",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "undeployAccount");
    }
    /**
   * Stops API server and trading terminal for trading account replica.
   * The request will be ignored if trading account replica is already undeployed
   * (see https://metaapi.cloud/docs/provisioning/api/accountReplica/undeployAccountReplica/)
   * Method is accessible only with API access token
   * @param {string} accountId MetaTrader primary account id
   * @param {string} replicaId MetaTrader account replica id
   * @return {Promise} promise resolving when MetaTrader account replica is scheduled for undeployment
   */ undeployAccountReplica(accountId, replicaId) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("undeployAccountReplica");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}/undeploy`,
            method: "POST",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "undeployAccountReplica");
    }
    /**
   * Redeploys trading account. This is equivalent to undeploy immediately followed by deploy
   * (see https://metaapi.cloud/docs/provisioning/api/account/redeployAccount/)
   * Method is accessible only with API access token
   * @param {string} id MetaTrader account id
   * @return {Promise} promise resolving when MetaTrader account is scheduled for redeployment
   */ redeployAccount(id) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("redeployAccount");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${id}/redeploy`,
            method: "POST",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "redeployAccount");
    }
    /**
   * Redeploys trading account replica. This is equivalent to undeploy immediately followed by deploy.
   * (see https://metaapi.cloud/docs/provisioning/api/account/redeployAccountReplica/)
   * Method is accessible only with API access token
   * @param {string} accountId MetaTrader primary account id
   * @param {string} replicaId MetaTrader account replica id
   * @return {Promise} promise resolving when MetaTrader account replica is scheduled for redeployment
   */ redeployAccountReplica(accountId, replicaId) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("redeployAccountReplica");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}/redeploy`,
            method: "POST",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "redeployAccountReplica");
    }
    /**
   * 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.
   * (see https://metaapi.cloud/docs/provisioning/api/account/deleteAccount/).
   * Method is accessible only with API access token
   * @param {string} id Id of the account to be deleted
   * @return {Promise} promise resolving when MetaTrader account is scheduled for deletion
   */ deleteAccount(id) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("deleteAccount");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${id}`,
            method: "DELETE",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "deleteAccount");
    }
    /**
   * Removes a trading account replica and stops the API server serving the replica
   * (see https://metaapi.cloud/docs/provisioning/api/account/deleteAccountReplica/).
   * Method is accessible only with API access token
   * @param {string} accountId primary account id
   * @param {string} replicaId Id of the account replica to be deleted
   * @return {Promise} promise resolving when MetaTrader account replica is scheduled for deletion
   */ deleteAccountReplica(accountId, replicaId) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("deleteAccountReplica");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}`,
            method: "DELETE",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "deleteAccountReplica");
    }
    /**
   * Updates trading account. 
   * Please redeploy the trading account in order for updated settings to take effect
   * (see https://metaapi.cloud/docs/provisioning/api/account/updateAccount/).
   * Method is accessible only with API access token
   * @param {string} id MetaTrader account id
   * @param {MetatraderAccountUpdateDto} account updated account information
   * @return {Promise} promise resolving when MetaTrader account is updated
   */ updateAccount(id, account) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("updateAccount");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${id}`,
            method: "PUT",
            headers: {
                "auth-token": this._token
            },
            json: true,
            data: account
        };
        return this._httpClient.request(opts, "updateAccount");
    }
    /**
   * Updated MetaTrader account replica data
   * @typedef {Object} UpdatedMetatraderAccountReplicaDto
   * @property {number} [magic] Magic value the trades should be performed using.
   * When manualTrades field is set to true, magic value must be 0
   * @property {number} [quoteStreamingIntervalInSeconds] Quote streaming interval in seconds. Set to 0 in order to
   * receive quotes on each tick. Default value is 2.5 seconds. Intervals less than 2.5 seconds are supported
   * only for G2
   * @property {Array<string>} [tags] MetaTrader account tags
   * @property {Object} [metadata] extra information which can be stored together with your account
   * @property {number} [resourceSlots] 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 CooyFactory API, then you can increase resourceSlots to get a lower trade
   * copying latency. Please note that allocating extra resource slots is a paid option. Default is 1
   * @property {number} [copyFactoryResourceSlots] 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.
   * Default is 1.
   */ /**
   * Updates trading account replica (see
   * https://metaapi.cloud/docs/provisioning/api/account/updateAccountReplica/).
   * Method is accessible only with API access token
   * @param {string} accountId MetaTrader primary account id
   * @param {string} replicaId MetaTrader account replica id
   * @param {UpdatedMetatraderAccountReplicaDto} metatraderAccount updated account replica information
   * @return {Promise} promise resolving when MetaTrader account replica is updated
   */ updateAccountReplica(accountId, replicaId, metatraderAccount) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("updateAccountReplica");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}`,
            method: "PUT",
            headers: {
                "auth-token": this._token
            },
            json: true,
            data: metatraderAccount
        };
        return this._httpClient.request(opts, "updateAccountReplica");
    }
    /**
   * 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 (see
   * https://metaapi.cloud/docs/provisioning/api/account/increaseReliability/).
   * Method is accessible only with API access token
   * @param {string} id MetaTrader account id
   * @return {Promise} promise resolving when MetaTrader account reliability is increased
   */ increaseReliability(id) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("increaseReliability");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${id}/increase-reliability`,
            method: "POST",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "increaseReliability");
    }
    /**
   * 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 (see
   * https://metaapi.cloud/docs/provisioning/api/account/enableRiskManagementApi/).
   * Method is accessible only with API access token
   * @param {string} id MetaTrader account id
   * @return {Promise} promise resolving when account risk management is enabled
   */ enableRiskManagementApi(id) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("enableRiskManagementApi");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${id}/enable-risk-management-api`,
            method: "POST",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "enableRiskManagementApi");
    }
    /**
   * 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
   * https://metaapi.cloud/docs/provisioning/api/account/enableCopyFactoryApi/).
   * @param {string} id MetaTrader account id
   * @param {Array<CopyFactoryRoles>} copyFactoryRoles Copy factory roles
   * @param {number} copyFactoryResourceSlots Copy factory resource slots
   * @return {Promise} promise resolving when account copy factory is enabled
   */ enableCopyFactoryApi(id, copyFactoryRoles, copyFactoryResourceSlots) {
        const opts = {
            url: `${this._host}/users/current/accounts/${id}/enable-copy-factory-api`,
            method: "POST",
            headers: {
                "auth-token": this._token
            },
            json: true,
            data: {
                copyFactoryRoles,
                copyFactoryResourceSlots
            }
        };
        return this._httpClient.request(opts, "enableCopyFactoryApi");
    }
    /**
   * Enables MetaStats API for trading account.
   * The account will be temporary stopped to perform this action.
   * Note that this is a paid option (see
   * https://metaapi.cloud/docs/provisioning/api/account/enableMetaStatsApi/).
   * Method is accessible only with API access token
   * @param {string} id MetaTrader account id
   * @return {Promise} promise resolving when account MetaStats API is enabled
   */ enableMetaStatsApi(id) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("enableMetaStatsApi");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${id}/enable-metastats-api`,
            method: "POST",
            headers: {
                "auth-token": this._token
            },
            json: true
        };
        return this._httpClient.request(opts, "enableMetaStatsApi");
    }
    /**
   * Configuration link
   * @typedef {Object} ConfigurationLink
   * @property {string} configurationLink Secure link to allow end user to configure account directly
   */ /**
   * Generates trading account configuration link by account id.
   * (see https://metaapi.cloud/docs/provisioning/api/account/createConfigurationLink/)
   * This link can be used by the end user to enter trading account login and password or change the password.
   * Method is accessible only with API access token
   * @param {string} accountId Trading account id
   * @param {number} [ttlInDays] Lifetime of the link in days. Default is 7.
   * @return {Promise<ConfigurationLink>} promise resolving with configuration link
   */ createConfigurationLink(accountId, ttlInDays) {
        if (this._isNotJwtToken()) {
            return this._handleNoAccessError("createConfigurationLink");
        }
        const opts = {
            url: `${this._host}/users/current/accounts/${accountId}/configuration-link`,
            method: "PUT",
            headers: {
                "auth-token": this._token
            },
            params: {
                ttlInDays: ttlInDays
            },
            json: true
        };
        return this._httpClient.request(opts, "createConfigurationLink");
    }
};

//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport {NewMetatraderAccountDto, MetatraderAccountUpdateDto} from './metatraderAccount.client';\nimport MetaApiClient from '../metaApi.client';\nimport randomstring from 'randomstring';\n\n/**\n * metaapi.cloud MetaTrader account API client (see https://metaapi.cloud/docs/provisioning/)\n */\nexport default class MetatraderAccountClient extends MetaApiClient {\n\n  /**\n   * Metatrader account replica model\n   * @typedef {Object} MetatraderAccountReplicaDto\n   * @property {string} _id Unique account replica id\n   * @property {State} state Current account replica state\n   * @property {number} magic Magic value the trades should be performed using\n   * @property {ConnectionStatus} connectionStatus Connection status of the MetaTrader terminal to the application\n   * @property {string} quoteStreamingIntervalInSeconds Quote streaming interval in seconds. Set to 0 in order to \n   * receive quotes on each tick. Intervals less than 2.5 seconds are supported only for G2\n   * @property {string} [symbol] Any symbol provided by broker (required for G1 only)\n   * @property {Reliability} reliability Used to increase the reliability of the account replica. High is a recommended value\n   * for production environment\n   * @property {Array<string>} tags User-defined account replica tags\n   * @property {Object} [metadata] Extra information which can be stored together with your account replica. \n   * Total length of this field after serializing it to JSON is limited to 1024 characters\n   * @property {number} resourceSlots Number of resource slots to allocate to account replica. 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 CooyFactory 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   * @property {number} copyFactoryResourceSlots Number of CopyFactory 2 resource slots to allocate to account replica.\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   * @property {string} region Region id to deploy account replica at. One of returned by the /users/current/regions endpoint\n   * @property {string} createdAt The time account replica was created at, in ISO format\n   * @property {MetatraderAccountDto} primaryAccount Primary account\n   */\n\n  /**\n   * MetaTrader account model\n   * @typedef {Object} MetatraderAccountDto\n   * @property {string} _id Unique account id\n   * @property {State} state Current account state\n   * @property {number} magic Magic value the trades should be performed using\n   * @property {ConnectionStatus} connectionStatus Connection status of the MetaTrader terminal to the application\n   * @property {string} quoteStreamingIntervalInSeconds Quote streaming interval in seconds. Set to 0 in order to \n   * receive quotes on each tick. Intervals less than 2.5 seconds are supported only for G2\n   * @property {string} [symbol] Any symbol provided by broker (required for G1 only)\n   * @property {Reliability} reliability Used to increase the reliability of the account. High is a recommended value\n   * for production environment\n   * @property {Array<string>} tags User-defined account tags\n   * @property {Object} [metadata] Extra information which can be stored together with your account. \n   * Total length of this field after serializing it to JSON is limited to 1024 characters\n   * @property {number} resourceSlots 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 CooyFactory 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   * @property {number} copyFactoryResourceSlots 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   * @property {string} region Region id to deploy account at. One of returned by the /users/current/regions endpoint\n   * @property {string} createdAt The time account was created at, in ISO format\n   * @property {string} name Human-readable account name\n   * @property {boolean} manualTrades Flag indicating if trades should be placed as manual trades. Supported on G2 only\n   * @property {number} [slippage] Default trade slippage in points. Should be greater or equal to zero. If not\n   * specified, system internal setting will be used which we believe is reasonable for most cases\n   * @property {string} [provisioningProfileId] Id of the provisioning profile that was used as the basis for \n   * creating this account\n   * @property {string} [login] MetaTrader account login\n   * @property {string} server MetaTrader server name to connect to \n   * @property {Type} type Account type. Executing accounts as cloud-g2 is faster and cheaper\n   * @property {Version} version MetaTrader version\n   * @property {number} hash Hash-code of the account\n   * @property {string} baseCurrency 3-character ISO currency code of the account base currency.\n   * The setting is to be used for copy trading accounts which use national currencies only, such as some Brazilian\n   * brokers. You should not alter this setting unless you understand what you are doing.\n   * @property {Array<CopyFactoryRoles>} copyFactoryRoles Account roles for CopyFactory2 application\n   * @property {boolean} riskManagementApiEnabled Flag indicating that risk management API is enabled on\n   * account\n   * @property {boolean} metastatsApiEnabled Flag indicating that MetaStats API is enabled on account\n   * @property {Array<AccountConnection>} connections Active account connections\n   * @property {boolean} primaryReplica Flag indicating that account is primary\n   * @property {string} userId User id\n   * @property {string} [primaryAccountId] Primary account id. Only replicas can have this field\n   * @property {Array<MetatraderAccountReplicaDto>} accountReplicas MetaTrader account replicas\n   */\n\n\n  /**\n   * MetaTrader account list model\n   * @typedef {Object} MetatraderAccountListDto\n   * @property {number} count MetaTrader accounts count\n   * @property {Array<MetatraderAccountDto>} items MetaTrader accounts list\n   */\n\n  /**\n   * Account connection\n   * @typedef {Object} AccountConnection\n   * @property {string} region Region the account is connected at\n   * @property {string} zone Availability zone the account is connected at\n   * @property {string} application Application the account is connected to, one of `MetaApi`, `CopyFactory subscriber`,\n   * `CopyFactory provider`, `CopyFactory history import`, `Risk management`\n   */\n\n  /**\n   * MT version\n   * @typedef {4 | 5} Version\n   */\n\n  /**\n   * MT platform\n   * @typedef {'mt4' | 'mt5'} Platform\n   */\n\n  /**\n   * Account type\n   * @typedef {'cloud-g1' | 'cloud-g2'} Type\n   */\n\n  /**\n   * Account state\n   * @typedef {'CREATED' | 'DEPLOYING' | 'DEPLOYED' | 'DEPLOY_FAILED' | 'UNDEPLOYING' | 'UNDEPLOYED' |\n   * 'UNDEPLOY_FAILED' | 'DELETING' | 'DELETE_FAILED' | 'REDEPLOY_FAILED' | 'DRAFT'} State\n   */\n\n  /**\n   * Account connection status\n   * @typedef {'CONNECTED' | 'DISCONNECTED' | 'DISCONNECTED_FROM_BROKER'} ConnectionStatus\n   */\n\n  /**\n   * Account reliability\n   * @typedef {'high' | 'regular'} Reliability\n   */\n\n  /**\n   * CopyFactory roles\n   * @typedef {'SUBSCRIBER' | 'PROVIDER'} CopyFactoryRoles\n   */\n\n  /**\n   * Sort order\n   * @typedef {'asc' | 'desc'} SortOrder\n   */\n\n  /**\n   * Get accounts api version\n   * @typedef {'1' | '2'} GetAccountsApiVersion\n   */\n\n  /**\n   * @typedef {Object} AccountsFilter\n   * @property {number} [offset] Search offset (defaults to 0) (must be greater or equal to 0)\n   * @property {number} [limit] Search limit (defaults to 1000) \n   * (must be greater or equal to 1 and less or equal to 1000)\n   * @property {Array<Version> | Version} [version] MT version\n   * @property {Array<Type> | Type} [type] Account type\n   * @property {Array<State> | State} [state] Account state\n   * @property {Array<ConnectionStatus> | ConnectionStatus} [connectionStatus] Connection status\n   * @property {string} [query] Searches over _id, name, server and login to match query\n   * @property {string} [provisioningProfileId] Provisioning profile id\n   * @property {SortOrder} [sortOrder] Sort order for stateChangedAt field, default is no order\n   * @property {Array<string> | string} [region] Available region\n   * @property {Array<CopyFactoryRoles> | CopyFactoryRoles} [copyFactoryRoles] Account roles for CopyFactory2 API\n   */\n\n  /**\n   * Returns trading accounts belonging to the current user (see https://metaapi.cloud/docs/provisioning/api/account/readAccounts/)\n   * Method is accessible only with API access token\n   * @param {AccountsFilter} [accountsFilter] optional filter\n   * @param {GetAccountsApiVersion} [apiVersion] api version to use\n   * @return {Promise<Array<MetatraderAccountDto> | MetatraderAccountListDto>} promise resolving with MetaTrader accounts found\n   */\n  getAccounts(accountsFilter = {}, apiVersion) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('getAccounts');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts`,\n      method: 'GET',\n      params: accountsFilter,\n      headers: {\n        'auth-token': this._token,\n      },\n      json: true\n    };\n    if (apiVersion) {\n      opts.headers['api-version'] = apiVersion;\n    }\n    return this._httpClient.request(opts, 'getAccounts');\n  }\n\n  /**\n   * Returns trading account by id (see https://metaapi.cloud/docs/provisioning/api/account/readAccount/)\n   * Method is accessible only with API access token\n   * @param {string} id MetaTrader account id\n   * @return {Promise<MetatraderAccountDto>} promise resolving with MetaTrader account found\n   */\n  getAccount(id) {\n    const opts = {\n      url: `${this._host}/users/current/accounts/${id}`,\n      method: 'GET',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'getAccount');\n  }\n\n  /**\n   * Returns trading account replica by trading account id and replica id (see \n   * https://metaapi.cloud/docs/provisioning/api/accountReplica/readAccountReplica/)\n   * Method is accessible only with API access token\n   * @param {string} accountId MetaTrader primary account id\n   * @param {string} replicaId MetaTrader account replica id\n   * @return {Promise<MetatraderAccountReplicaDto>} promise resolving with MetaTrader account replica found\n   */\n  getAccountReplica(accountId, replicaId) {\n    const opts = {\n      url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}`,\n      method: 'GET',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'getAccountReplica');\n  }\n\n  /**\n   * Returns replicas for a trading account (see \n   * https://metaapi.cloud/docs/provisioning/api/accountReplica/readAccountReplicas/)\n   * Method is accessible only with API access token\n   * @param {string} accountId Primary account id\n   * @return {Promise<Array<MetatraderAccountReplicaDto>>} promise resolving with MetaTrader account replicas found\n   */\n  getAccountReplicas(accountId) {\n    const opts = {\n      url: `${this._host}/users/current/accounts/${accountId}/replicas`,\n      method: 'GET',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'getAccountReplicas');\n  }\n\n  /**\n   * MetaTrader account id model\n   * @typedef {Object} MetatraderAccountIdDto\n   * @property {string} id MetaTrader account unique identifier\n   * @property {string} state State of the account. Possible values are 'UNDEPLOYED', 'DEPLOYED', 'DRAFT'\n   */\n\n  /**\n   * Adds a trading account and starts a cloud API server for the trading account (see \n   * https://metaapi.cloud/docs/provisioning/api/account/createAccount/).\n   * It can take some time for the API server and trading terminal to start and connect to broker.\n   * You can use the `connectionStatus` replica field to monitor the current status of the trading account.\n   * Method is accessible only with API access token\n   * @param {NewMetatraderAccountDto} account MetaTrader account data\n   * @return {Promise<MetatraderAccountIdDto>} promise resolving with an id and state of the MetaTrader account created\n   */\n  createAccount(account) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('createAccount');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token,\n        'transaction-id': randomstring.generate(32)\n      },\n      json: true,\n      data: account\n    };\n    return this._httpClient.request(opts, 'createAccount');\n  }\n\n  /**\n   * New MetaTrader account replica model\n   * @typedef {Object} NewMetaTraderAccountReplicaDto\n   * @property {string} [symbol] Any MetaTrader symbol your broker provides historical market data for. \n   * This value should be specified for G1 accounts only and only in case your MT account fails to connect to broker.\n   * @property {number} magic Magic value the trades should be performed using.\n   * When manualTrades field is set to true, magic value must be 0\n   * @property {string} [quoteStreamingIntervalInSeconds] Quote streaming interval in seconds. Set to 0 in order to \n   * receive quotes on each tick. Default value is 2.5 seconds. Intervals less than 2.5 seconds are supported only for G2\n   * @property {Array<string>} [tags] User-defined account replica tags\n   * @property {Object} [metadata] Extra information which can be stored together with your account replica. \n   * Total length of this field after serializing it to JSON is limited to 1024 characters\n   * @property {Reliability} [reliability] Used to increase the reliability of the account replica. High is a recommended value \n   * for production environment. Default value is high\n   * @property {number} [resourceSlots] Number of resource slots to allocate to account replica. 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 CooyFactory 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. Default is 1.\n   * @property {number} [copyFactoryResourceSlots] Number of CopyFactory 2 resource slots to allocate to account replica.\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   * Default is 1.\n   * @property {string} region Region id to deploy account replica at. One of returned by the /users/current/regions endpoint\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   * (see https://metaapi.cloud/docs/provisioning/api/accountReplica/createAccountReplica/).\n   * It can take some time for the API server and trading terminal to start and connect to broker.\n   * You can use the `connectionStatus` replica field to monitor the current status of the replica.\n   * Method is accessible only with API access token\n   * @param {string} accountId primary account id\n   * @param {NewMetaTraderAccountReplicaDto} account MetaTrader account data\n   * @return {Promise<MetatraderAccountIdDto>} promise resolving with an id and state of the MetaTrader account replica created\n   */\n  createAccountReplica(accountId, account) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('createAccountReplica');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${accountId}/replicas`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token,\n        'transaction-id': randomstring.generate(32)\n      },\n      json: true,\n      data: account\n    };\n    return this._httpClient.request(opts, 'createAccountReplica');\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   * (see https://metaapi.cloud/docs/provisioning/api/account/deployAccount/)\n   * Method is accessible only with API access token\n   * @param {string} id MetaTrader account id\n   * @return {Promise} promise resolving when MetaTrader account is scheduled for deployment\n   */\n  deployAccount(id) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('deployAccount');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${id}/deploy`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'deployAccount');\n  }\n\n  /**\n   * Starts API server and trading terminal for trading account replica.\n   * This request will be ignored if the replica is already deployed\n   * (see https://metaapi.cloud/docs/provisioning/api/accountReplica/deployAccountReplica/)\n   * Method is accessible only with API access token\n   * @param {string} accountId MetaTrader account id\n   * @param {string} replicaId MetaTrader account replica id\n   * @return {Promise} promise resolving when MetaTrader account replica is scheduled for deployment\n   */\n  deployAccountReplica(accountId, replicaId) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('deployAccountReplica');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}/deploy`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'deployAccountReplica');\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   * (see https://metaapi.cloud/docs/provisioning/api/account/undeployAccount/)\n   * Method is accessible only with API access token\n   * @param {string} id MetaTrader account id\n   * @return {Promise} promise resolving when MetaTrader account is scheduled for undeployment\n   */\n  undeployAccount(id) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('undeployAccount');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${id}/undeploy`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'undeployAccount');\n  }\n\n  /**\n   * Stops API server and trading terminal for trading account replica.\n   * The request will be ignored if trading account replica is already undeployed\n   * (see https://metaapi.cloud/docs/provisioning/api/accountReplica/undeployAccountReplica/)\n   * Method is accessible only with API access token\n   * @param {string} accountId MetaTrader primary account id\n   * @param {string} replicaId MetaTrader account replica id\n   * @return {Promise} promise resolving when MetaTrader account replica is scheduled for undeployment\n   */\n  undeployAccountReplica(accountId, replicaId) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('undeployAccountReplica');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}/undeploy`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'undeployAccountReplica');\n  }\n\n  /**\n   * Redeploys trading account. This is equivalent to undeploy immediately followed by deploy\n   * (see https://metaapi.cloud/docs/provisioning/api/account/redeployAccount/)\n   * Method is accessible only with API access token\n   * @param {string} id MetaTrader account id\n   * @return {Promise} promise resolving when MetaTrader account is scheduled for redeployment\n   */\n  redeployAccount(id) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('redeployAccount');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${id}/redeploy`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'redeployAccount');\n  }\n\n  /**\n   * Redeploys trading account replica. This is equivalent to undeploy immediately followed by deploy.\n   * (see https://metaapi.cloud/docs/provisioning/api/account/redeployAccountReplica/)\n   * Method is accessible only with API access token\n   * @param {string} accountId MetaTrader primary account id\n   * @param {string} replicaId MetaTrader account replica id\n   * @return {Promise} promise resolving when MetaTrader account replica is scheduled for redeployment\n   */\n  redeployAccountReplica(accountId, replicaId) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('redeployAccountReplica');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}/redeploy`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'redeployAccountReplica');\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   * (see https://metaapi.cloud/docs/provisioning/api/account/deleteAccount/).\n   * Method is accessible only with API access token\n   * @param {string} id Id of the account to be deleted\n   * @return {Promise} promise resolving when MetaTrader account is scheduled for deletion\n   */\n  deleteAccount(id) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('deleteAccount');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${id}`,\n      method: 'DELETE',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'deleteAccount');\n  }\n\n  /**\n   * Removes a trading account replica and stops the API server serving the replica\n   * (see https://metaapi.cloud/docs/provisioning/api/account/deleteAccountReplica/).\n   * Method is accessible only with API access token\n   * @param {string} accountId primary account id\n   * @param {string} replicaId Id of the account replica to be deleted\n   * @return {Promise} promise resolving when MetaTrader account replica is scheduled for deletion\n   */\n  deleteAccountReplica(accountId, replicaId) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('deleteAccountReplica');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}`,\n      method: 'DELETE',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'deleteAccountReplica');\n  }\n\n  /**\n   * Updates trading account. \n   * Please redeploy the trading account in order for updated settings to take effect\n   * (see https://metaapi.cloud/docs/provisioning/api/account/updateAccount/).\n   * Method is accessible only with API access token\n   * @param {string} id MetaTrader account id\n   * @param {MetatraderAccountUpdateDto} account updated account information\n   * @return {Promise} promise resolving when MetaTrader account is updated\n   */\n  updateAccount(id, account) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('updateAccount');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${id}`,\n      method: 'PUT',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true,\n      data: account\n    };\n    return this._httpClient.request(opts, 'updateAccount');\n  }\n\n  /**\n   * Updated MetaTrader account replica data\n   * @typedef {Object} UpdatedMetatraderAccountReplicaDto\n   * @property {number} [magic] Magic value the trades should be performed using.\n   * When manualTrades field is set to true, magic value must be 0\n   * @property {number} [quoteStreamingIntervalInSeconds] Quote streaming interval in seconds. Set to 0 in order to\n   * receive quotes on each tick. Default value is 2.5 seconds. Intervals less than 2.5 seconds are supported\n   * only for G2\n   * @property {Array<string>} [tags] MetaTrader account tags\n   * @property {Object} [metadata] extra information which can be stored together with your account\n   * @property {number} [resourceSlots] 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 CooyFactory 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. Default is 1\n   * @property {number} [copyFactoryResourceSlots] 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   * Default is 1.\n   */\n\n  /**\n   * Updates trading account replica (see\n   * https://metaapi.cloud/docs/provisioning/api/account/updateAccountReplica/).\n   * Method is accessible only with API access token\n   * @param {string} accountId MetaTrader primary account id\n   * @param {string} replicaId MetaTrader account replica id\n   * @param {UpdatedMetatraderAccountReplicaDto} metatraderAccount updated account replica information\n   * @return {Promise} promise resolving when MetaTrader account replica is updated\n   */\n  updateAccountReplica(accountId, replicaId, metatraderAccount) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('updateAccountReplica');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${accountId}/replicas/${replicaId}`,\n      method: 'PUT',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true,\n      data: metatraderAccount\n    };\n    return this._httpClient.request(opts, 'updateAccountReplica');\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 (see\n   * https://metaapi.cloud/docs/provisioning/api/account/increaseReliability/).\n   * Method is accessible only with API access token\n   * @param {string} id MetaTrader account id\n   * @return {Promise} promise resolving when MetaTrader account reliability is increased\n   */\n  increaseReliability(id) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('increaseReliability');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${id}/increase-reliability`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'increaseReliability');\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 (see\n   * https://metaapi.cloud/docs/provisioning/api/account/enableRiskManagementApi/).\n   * Method is accessible only with API access token\n   * @param {string} id MetaTrader account id\n   * @return {Promise} promise resolving when account risk management is enabled\n   */\n  enableRiskManagementApi(id) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('enableRiskManagementApi');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${id}/enable-risk-management-api`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'enableRiskManagementApi');\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   * https://metaapi.cloud/docs/provisioning/api/account/enableCopyFactoryApi/).\n   * @param {string} id MetaTrader account id\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  enableCopyFactoryApi(id, copyFactoryRoles, copyFactoryResourceSlots) {\n    const opts = {\n      url: `${this._host}/users/current/accounts/${id}/enable-copy-factory-api`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true,\n      data: {\n        copyFactoryRoles,\n        copyFactoryResourceSlots\n      }\n    };\n    return this._httpClient.request(opts, 'enableCopyFactoryApi');\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 (see\n   * https://metaapi.cloud/docs/provisioning/api/account/enableMetaStatsApi/).\n   * Method is accessible only with API access token\n   * @param {string} id MetaTrader account id\n   * @return {Promise} promise resolving when account MetaStats API is enabled\n   */\n  enableMetaStatsApi(id) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('enableMetaStatsApi');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${id}/enable-metastats-api`,\n      method: 'POST',\n      headers: {\n        'auth-token': this._token\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'enableMetaStatsApi');\n  }\n\n  /**\n   * Configuration link\n   * @typedef {Object} ConfigurationLink\n   * @property {string} configurationLink Secure link to allow end user to configure account directly\n   */\n\n  /**\n   * Generates trading account configuration link by account id.\n   * (see https://metaapi.cloud/docs/provisioning/api/account/createConfigurationLink/)\n   * This link can be used by the end user to enter trading account login and password or change the password.\n   * Method is accessible only with API access token\n   * @param {string} accountId Trading 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  createConfigurationLink(accountId, ttlInDays) {\n    if (this._isNotJwtToken()) {\n      return this._handleNoAccessError('createConfigurationLink');\n    }\n    const opts = {\n      url: `${this._host}/users/current/accounts/${accountId}/configuration-link`,\n      method: 'PUT',\n      headers: {\n        'auth-token': this._token\n      },\n      params: {\n        ttlInDays: ttlInDays\n      },\n      json: true\n    };\n    return this._httpClient.request(opts, 'createConfigurationLink');\n  }\n\n}\n"],"names":["MetatraderAccountClient","MetaApiClient","getAccounts","accountsFilter","apiVersion","_isNotJwtToken","_handleNoAccessError","opts","url","_host","method","params","headers","_token","json","_httpClient","request","getAccount","id","getAccountReplica","accountId","replicaId","getAccountReplicas","createAccount","account","randomstring","generate","data","createAccountReplica","deployAccount","deployAccountReplica","undeployAccount","undeployAccountReplica","redeployAccount","redeployAccountReplica","deleteAccount","deleteAccountReplica","updateAccount","updateAccountReplica","metatraderAccount","increaseReliability","enableRiskManagementApi","enableCopyFactoryApi","copyFactoryRoles","copyFactoryResourceSlots","enableMetaStatsApi","createConfigurationLink","ttlInDays"],"mappings":"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"}