@mywebapi.com/sdk 0.1.0

package/dist/generated/mt4-v2-symbols.d.ts

@@ -0,0 +1,273 @@
+/**
+ * Generated by orval v8.19.0 🍺
+ * Do not edit manually.
+ * JSON-Pure WebAPI for MT4/MT5
+ * It uses native MetaQuote ManagerAPI for both MT4 and MT5 connection. Plus, it keep pumping connection active, so all *Get calls will run much faster, than *Request.<br/>Here partially used the idea of JSON-Pure API, only HTTP code 200 is acceptable. Other codes signal about errors on server side, which are out of control of client, like wrong parameters, platform unavailability, etc.
+ * OpenAPI spec version: 2.0
+ */
+import type { BooleanApiResponse, GetSymbolInfoGetParams, GetSymbolInfoUpdatedParams, MT4SymbolChangeRequest, MT4SymbolConfigApiResponse, MT4SymbolConfigListApiResponse, MT4SymbolConfigUpdate, MT4SymbolDaySessionsListApiResponse, MT4SymbolGroupListApiResponse, MT4SymbolInfoApiResponse, MT4SymbolInfoListApiResponse, PostSymbolSendTickParams } from './model';
+export type getSymbolInfoGetResponse200 = {
+    data: MT4SymbolInfoApiResponse;
+    status: 200;
+};
+export type getSymbolInfoGetResponseSuccess = (getSymbolInfoGetResponse200) & {
+    headers: Headers;
+};
+export type getSymbolInfoGetResponse = (getSymbolInfoGetResponseSuccess);
+export declare const getGetSymbolInfoGetUrl: (tradePlatform: string, params?: GetSymbolInfoGetParams) => string;
+/**
+ * Current cached market data for a single symbol.
+ *
+ * Pump-cached read — Bid/Ask/High/Low/Spread/Digits and last-tick time
+ * for the requested instrument. Returns NotFound-shaped envelope (the
+ * wrapper-level result code surfaces in ManagerAPICode / ErrorCode)
+ * when the symbol is not loaded on the connected server.
+ * @summary Get symbol market data (cached)
+ */
+export declare const getSymbolInfoGet: (tradePlatform: string, params?: GetSymbolInfoGetParams, options?: RequestInit) => Promise<getSymbolInfoGetResponse>;
+export type getSymbolInfoUpdatedResponse200 = {
+    data: MT4SymbolInfoListApiResponse;
+    status: 200;
+};
+export type getSymbolInfoUpdatedResponseSuccess = (getSymbolInfoUpdatedResponse200) & {
+    headers: Headers;
+};
+export type getSymbolInfoUpdatedResponse = (getSymbolInfoUpdatedResponseSuccess);
+export declare const getGetSymbolInfoUpdatedUrl: (tradePlatform: string, params?: GetSymbolInfoUpdatedParams) => string;
+/**
+ * Snapshot of all symbols that have been updated since the last pump flush, keyed by symbol name (values-only on the wire).
+ *
+ * Pump-cached read — instant local lookup, no MT4 round-trip. Useful for
+ * bulk refresh of a quote panel or watchlist. Sort key is the symbol
+ * name; cursors are opaque base64 strings.
+ * @summary List updated symbols (cached)
+ */
+export declare const getSymbolInfoUpdated: (tradePlatform: string, params?: GetSymbolInfoUpdatedParams, options?: RequestInit) => Promise<getSymbolInfoUpdatedResponse>;
+export type getSymbolsGroupsGetResponse200 = {
+    data: MT4SymbolGroupListApiResponse;
+    status: 200;
+};
+export type getSymbolsGroupsGetResponseSuccess = (getSymbolsGroupsGetResponse200) & {
+    headers: Headers;
+};
+export type getSymbolsGroupsGetResponse = (getSymbolsGroupsGetResponseSuccess);
+export declare const getGetSymbolsGroupsGetUrl: (tradePlatform: string) => string;
+/**
+ * All configured symbol groups (security categories) from the pump cache.
+ *
+ * Pump-cached read — returns the broker-configured security groups
+ * (e.g. "Forex", "CFD", "Metals"). Each entry only carries Name and
+ * Description; ConSymbolGroup has no additional fields on the
+ * MT4-side struct.
+ * @summary List symbol groups (cached)
+ */
+export declare const getSymbolsGroupsGet: (tradePlatform: string, options?: RequestInit) => Promise<getSymbolsGroupsGetResponse>;
+export type getCfgRequestSymbolResponse200 = {
+    data: MT4SymbolConfigListApiResponse;
+    status: 200;
+};
+export type getCfgRequestSymbolResponseSuccess = (getCfgRequestSymbolResponse200) & {
+    headers: Headers;
+};
+export type getCfgRequestSymbolResponse = (getCfgRequestSymbolResponseSuccess);
+export declare const getGetCfgRequestSymbolUrl: (tradePlatform: string) => string;
+/**
+ * Full server-side configuration for every symbol on the platform.
+ *
+ * Manager (live) call. Heavy response — typical platforms have dozens
+ * to hundreds of symbols, each with a 50+ field `ConSymbol`
+ * structure. Pair with `Idempotency-Key` on retry.
+ * @summary List symbol configs
+ */
+export declare const getCfgRequestSymbol: (tradePlatform: string, options?: RequestInit) => Promise<getCfgRequestSymbolResponse>;
+export type getCfgRequestSymbolSymbolResponse200 = {
+    data: MT4SymbolConfigApiResponse;
+    status: 200;
+};
+export type getCfgRequestSymbolSymbolResponseSuccess = (getCfgRequestSymbolSymbolResponse200) & {
+    headers: Headers;
+};
+export type getCfgRequestSymbolSymbolResponse = (getCfgRequestSymbolSymbolResponseSuccess);
+export declare const getGetCfgRequestSymbolSymbolUrl: (tradePlatform: string, symbol: string) => string;
+/**
+ * Full server-side configuration for a single symbol by name.
+ *
+ * Manager (live) call. Returns NotFound envelope when the symbol is
+ * not configured on the server. Same DTO shape as `CfgRequestSymbol`'s
+ * list element.
+ * @summary Get symbol config
+ */
+export declare const getCfgRequestSymbolSymbol: (tradePlatform: string, symbol: string, options?: RequestInit) => Promise<getCfgRequestSymbolSymbolResponse>;
+export type getSymbolSessionsGetSymbolResponse200 = {
+    data: MT4SymbolDaySessionsListApiResponse;
+    status: 200;
+};
+export type getSymbolSessionsGetSymbolResponseSuccess = (getSymbolSessionsGetSymbolResponse200) & {
+    headers: Headers;
+};
+export type getSymbolSessionsGetSymbolResponse = (getSymbolSessionsGetSymbolResponseSuccess);
+export declare const getGetSymbolSessionsGetSymbolUrl: (tradePlatform: string, symbol: string) => string;
+/**
+ * Trading session windows for a symbol, per weekday.
+ *
+ * Returns the wrapper's `ConSymbol.Sessions[7]` array (one entry
+ * per weekday, 0=Sunday). Each weekday entry carries up to three Quote
+ * (price) windows and up to three Trade (order acceptance) windows
+ * plus overnight flags. Closes the TODO documented in
+ * `MT4SymbolConfig`: the parent `CfgRequestSymbol` endpoint
+ * drops the nested Sessions array to keep the DTO manageable; this
+ * dedicated endpoint exposes it.
+ * @summary Get symbol sessions
+ */
+export declare const getSymbolSessionsGetSymbol: (tradePlatform: string, symbol: string, options?: RequestInit) => Promise<getSymbolSessionsGetSymbolResponse>;
+export type postCfgUpdateSymbolSymbolResponse200 = {
+    data: MT4SymbolConfigApiResponse;
+    status: 200;
+};
+export type postCfgUpdateSymbolSymbolResponseSuccess = (postCfgUpdateSymbolSymbolResponse200) & {
+    headers: Headers;
+};
+export type postCfgUpdateSymbolSymbolResponse = (postCfgUpdateSymbolSymbolResponseSuccess);
+export declare const getPostCfgUpdateSymbolSymbolUrl: (tradePlatform: string, symbol: string) => string;
+/**
+ * Update a symbol's full configuration — Type 1 mutator with secret-preservation read.
+ *
+ * Completes the User/Group/Symbol Type 1 mutator triad. Same flow as
+ * `UserRecordUpdate` and `GroupRecordUpdate`: read the existing
+ * `ConSymbol` from MT4 server, overlay the
+ * `MT4SymbolConfigUpdate` DTO over it, write the merged structure
+ * back. Preserves the `Sessions` nested array, reserved/unused
+ * padding, and server-derived fields (`Count`, `CountOriginal`,
+ * `FilterCounter`, `Point`, `Multiply`, tick-value pair)
+ * — those are `[MapperIgnoreTarget]`'d on the mapper.
+ *
+ * Idempotency-Key strongly recommended.
+ * @summary Update symbol config
+ */
+export declare const postCfgUpdateSymbolSymbol: (tradePlatform: string, symbol: string, mT4SymbolConfigUpdate?: MT4SymbolConfigUpdate, options?: RequestInit) => Promise<postCfgUpdateSymbolSymbolResponse>;
+export type patchSymbolConfigSymbolResponse200 = {
+    data: MT4SymbolConfigApiResponse;
+    status: 200;
+};
+export type patchSymbolConfigSymbolResponseSuccess = (patchSymbolConfigSymbolResponse200) & {
+    headers: Headers;
+};
+export type patchSymbolConfigSymbolResponse = (patchSymbolConfigSymbolResponseSuccess);
+export declare const getPatchSymbolConfigSymbolUrl: (tradePlatform: string, symbol: string) => string;
+/**
+ * Type 2 mutator — partial update of a symbol configuration. Same flow as `UserRecordPatch`; reads existing config live, overlays the patch, writes back.
+ * @summary Patch symbol config
+ */
+export declare const patchSymbolConfigSymbol: (tradePlatform: string, symbol: string, options?: RequestInit) => Promise<patchSymbolConfigSymbolResponse>;
+export type postSymbolAddSymbolResponse200 = {
+    data: BooleanApiResponse;
+    status: 200;
+};
+export type postSymbolAddSymbolResponseSuccess = (postSymbolAddSymbolResponse200) & {
+    headers: Headers;
+};
+export type postSymbolAddSymbolResponse = (postSymbolAddSymbolResponseSuccess);
+export declare const getPostSymbolAddSymbolUrl: (tradePlatform: string, symbol: string) => string;
+/**
+ * Add a symbol to the platform's active set — Type 1 mutator.
+ *
+ * Promotes a configured symbol into the platform's currently-pumping
+ * set so it starts receiving ticks and accepting orders. Reversible via
+ * `SymbolHide`.
+ *
+ * v1 exposes this as `GET /api/MT4/{tp}/SymbolAdd/{symbol}` — that
+ * is a historical REST violation (GET should be safe/idempotent). v2
+ * corrects the verb to POST without changing the wrapper behaviour. The
+ * path stays the same to keep traceability with the underlying wrapper
+ * method name; only the HTTP verb changes.
+ * @summary Add symbol
+ */
+export declare const postSymbolAddSymbol: (tradePlatform: string, symbol: string, options?: RequestInit) => Promise<postSymbolAddSymbolResponse>;
+export type postSymbolHideSymbolResponse200 = {
+    data: BooleanApiResponse;
+    status: 200;
+};
+export type postSymbolHideSymbolResponseSuccess = (postSymbolHideSymbolResponse200) & {
+    headers: Headers;
+};
+export type postSymbolHideSymbolResponse = (postSymbolHideSymbolResponseSuccess);
+export declare const getPostSymbolHideSymbolUrl: (tradePlatform: string, symbol: string) => string;
+/**
+ * Hide a symbol from the platform's active set — Type 1 mutator.
+ *
+ * Removes the symbol from the active subscription set; ticks stop flowing
+ * and orders are no longer accepted for that symbol. Reversible via
+ * `SymbolAdd`. v1 exposes this as a GET — v2 fixes to POST.
+ * @summary Hide symbol
+ */
+export declare const postSymbolHideSymbol: (tradePlatform: string, symbol: string, options?: RequestInit) => Promise<postSymbolHideSymbolResponse>;
+export type postSymbolsRefreshResponse200 = {
+    data: BooleanApiResponse;
+    status: 200;
+};
+export type postSymbolsRefreshResponseSuccess = (postSymbolsRefreshResponse200) & {
+    headers: Headers;
+};
+export type postSymbolsRefreshResponse = (postSymbolsRefreshResponseSuccess);
+export declare const getPostSymbolsRefreshUrl: (tradePlatform: string) => string;
+/**
+ * Refresh the symbol catalog from MT4 server — Type 1 mutator (no body).
+ *
+ * Forces the wrapper to reload its symbol catalog. Useful after admin
+ * tooling has added/edited symbols on the MT4 server side. v1 exposes
+ * this as GET — v2 fixes to POST (mutation of the wrapper's local state).
+ * @summary Refresh symbol catalog
+ */
+export declare const postSymbolsRefresh: (tradePlatform: string, options?: RequestInit) => Promise<postSymbolsRefreshResponse>;
+export type postSymbolChangeResponse200 = {
+    data: BooleanApiResponse;
+    status: 200;
+};
+export type postSymbolChangeResponseSuccess = (postSymbolChangeResponse200) & {
+    headers: Headers;
+};
+export type postSymbolChangeResponse = (postSymbolChangeResponseSuccess);
+export declare const getPostSymbolChangeUrl: (tradePlatform: string) => string;
+/**
+ * Adjusts the per-symbol trading attributes that dealers manage from the MT4 Manager UI — spread, stops-level, smoothing, quote color, execution mode.
+ *
+ * Manager-live POST. Maps 1:1 to the wrapper's `SymbolChange`
+ * call which marshals an entire `SymbolProperties` struct down
+ * to the native server. Only the seven editable fields are exposed
+ * on the v2 contract — the wrapper's 8-int reserved padding is
+ * filled with zeros by Mapperly automatically.
+ *
+ * This is intentionally separate from the heavier `CfgUpdateSymbol`
+ * Type 1 mutator: `SymbolChange` is the dealer-tier adjustment
+ * path; `CfgUpdateSymbol` changes structural symbol configuration
+ * (currency, calc mode, margin, swap) that requires admin privileges
+ * and broker-side coordination.
+ * @summary Change symbol attributes
+ */
+export declare const postSymbolChange: (tradePlatform: string, mT4SymbolChangeRequest?: MT4SymbolChangeRequest, options?: RequestInit) => Promise<postSymbolChangeResponse>;
+export type postSymbolSendTickResponse200 = {
+    data: BooleanApiResponse;
+    status: 200;
+};
+export type postSymbolSendTickResponseSuccess = (postSymbolSendTickResponse200) & {
+    headers: Headers;
+};
+export type postSymbolSendTickResponse = (postSymbolSendTickResponseSuccess);
+export declare const getPostSymbolSendTickUrl: (tradePlatform: string, params?: PostSymbolSendTickParams) => string;
+/**
+ * Injects a synthetic tick into the MT4 server for the given symbol — used to keep the feed alive on instruments where the upstream datafeed is paused, or to drive simulator tooling.
+ *
+ * Manager-live POST. The wrapper requires the manager account to hold
+ * the `Market Watch` permission; without it the server typically
+ * drops the connection rather than returning an error. The API-side
+ * `ResourceAccessAuthorize` on this endpoint guards against API
+ * callers without the appropriate platform-level permission, but
+ * broker-side mis-configuration of the underlying manager rights
+ * remains the consumer's responsibility.
+ *
+ * `bid` and `ask` are absolute prices, not deltas. Pass
+ * the symbol's last-known bid/ask if you only need to refresh the
+ * timestamp; pass adjusted prices to actually move the quote.
+ * @summary Send synthetic tick
+ */
+export declare const postSymbolSendTick: (tradePlatform: string, params?: PostSymbolSendTickParams, options?: RequestInit) => Promise<postSymbolSendTickResponse>;

package/dist/generated/mt4-v2-trades.d.ts

@@ -0,0 +1,356 @@
+/**
+ * Generated by orval v8.19.0 🍺
+ * Do not edit manually.
+ * JSON-Pure WebAPI for MT4/MT5
+ * It uses native MetaQuote ManagerAPI for both MT4 and MT5 connection. Plus, it keep pumping connection active, so all *Get calls will run much faster, than *Request.<br/>Here partially used the idea of JSON-Pure API, only HTTP code 200 is acceptable. Other codes signal about errors on server side, which are out of control of client, like wrong parameters, platform unavailability, etc.
+ * OpenAPI spec version: 2.0
+ */
+import type { BooleanApiResponse, GetAdmTradesRequestGroupParams, GetTradeRecordsRequestParams, GetTradesGetBySymbolParams, GetTradesGetParams, GetTradesRequestParams, MT4TradeApiResponse, MT4TradeListApiResponse, MT4TradeTransaction, MT4TradeTransactionApiResponse, MT4TradeUpdate, PostAdmTradesDeleteParams, PostTradeCheckStopsParams, PostTradesSyncStartParams } from './model';
+export type getTradesGetResponse200 = {
+    data: MT4TradeListApiResponse;
+    status: 200;
+};
+export type getTradesGetResponseSuccess = (getTradesGetResponse200) & {
+    headers: Headers;
+};
+export type getTradesGetResponse = (getTradesGetResponseSuccess);
+export declare const getGetTradesGetUrl: (tradePlatform: string, params?: GetTradesGetParams) => string;
+/**
+ * Pump-cached snapshot of all open trades on the platform, returned paginated. Sort key is the order ticket ascending. `?limit=` caps page size; without it all open trades come back in one page.
+ * @summary List open trades (cached)
+ */
+export declare const getTradesGet: (tradePlatform: string, params?: GetTradesGetParams, options?: RequestInit) => Promise<getTradesGetResponse>;
+export type getTradesGetTicketResponse200 = {
+    data: MT4TradeApiResponse;
+    status: 200;
+};
+export type getTradesGetTicketResponseSuccess = (getTradesGetTicketResponse200) & {
+    headers: Headers;
+};
+export type getTradesGetTicketResponse = (getTradesGetTicketResponseSuccess);
+export declare const getGetTradesGetTicketUrl: (tradePlatform: string, ticket: number) => string;
+/**
+ * Open trade by ticket from the pump cache (dictionary lookup variant).
+ *
+ * Counterpart to `TradeRecordGet/{order}` — both are pump reads,
+ * but the wrapper exposes two distinct call paths: `TradeRecordGet`
+ * uses a dedicated single-record method, while this endpoint looks the
+ * trade up in the open-trades dictionary. Behaviourally equivalent for
+ * open trades; `TradeRecordGet` can also resolve recently closed
+ * trades that linger in cache.
+ * @summary Get trade by ticket (cached)
+ */
+export declare const getTradesGetTicket: (tradePlatform: string, ticket: number, options?: RequestInit) => Promise<getTradesGetTicketResponse>;
+export type getTradesGetByLoginLoginGroupResponse200 = {
+    data: MT4TradeListApiResponse;
+    status: 200;
+};
+export type getTradesGetByLoginLoginGroupResponseSuccess = (getTradesGetByLoginLoginGroupResponse200) & {
+    headers: Headers;
+};
+export type getTradesGetByLoginLoginGroupResponse = (getTradesGetByLoginLoginGroupResponseSuccess);
+export declare const getGetTradesGetByLoginLoginGroupUrl: (tradePlatform: string, login: number, group: string) => string;
+/**
+ * Open trades for a single account from the pump cache.
+ *
+ * Pump-cached lookup, keyed by login + group. The group parameter is
+ * required because the wrapper organises trades by group internally —
+ * callers can fetch the group via `UserRecordGet/{login}` first.
+ * Empty list when the account has no open trades.
+ * @summary List trades by account (cached)
+ */
+export declare const getTradesGetByLoginLoginGroup: (tradePlatform: string, login: number, group: string, options?: RequestInit) => Promise<getTradesGetByLoginLoginGroupResponse>;
+export type getTradesGetBySymbolResponse200 = {
+    data: MT4TradeListApiResponse;
+    status: 200;
+};
+export type getTradesGetBySymbolResponseSuccess = (getTradesGetBySymbolResponse200) & {
+    headers: Headers;
+};
+export type getTradesGetBySymbolResponse = (getTradesGetBySymbolResponseSuccess);
+export declare const getGetTradesGetBySymbolUrl: (tradePlatform: string, params?: GetTradesGetBySymbolParams) => string;
+/**
+ * Open and pending orders for a specific symbol from the pump cache.
+ *
+ * Pump-cached snapshot — instant local lookup, no MT4 round-trip. Useful
+ * for per-instrument risk monitoring. Empty array is a legitimate result
+ * (no live trades on that symbol).
+ * @summary List trades by symbol (cached)
+ */
+export declare const getTradesGetBySymbol: (tradePlatform: string, params?: GetTradesGetBySymbolParams, options?: RequestInit) => Promise<getTradesGetBySymbolResponse>;
+export type getTradesGetByMarketResponse200 = {
+    data: MT4TradeListApiResponse;
+    status: 200;
+};
+export type getTradesGetByMarketResponseSuccess = (getTradesGetByMarketResponse200) & {
+    headers: Headers;
+};
+export type getTradesGetByMarketResponse = (getTradesGetByMarketResponseSuccess);
+export declare const getGetTradesGetByMarketUrl: (tradePlatform: string) => string;
+/**
+ * All market-condition (non-pending) open trades from the pump cache.
+ *
+ * Pump-cached snapshot of every open market order across all accounts.
+ * Pending orders (limits/stops) are excluded — for those query per-symbol
+ * or per-account. Empty array is a legitimate result on idle servers.
+ * @summary List market trades (cached)
+ */
+export declare const getTradesGetByMarket: (tradePlatform: string, options?: RequestInit) => Promise<getTradesGetByMarketResponse>;
+export type getTradeRecordGetOrderResponse200 = {
+    data: MT4TradeApiResponse;
+    status: 200;
+};
+export type getTradeRecordGetOrderResponseSuccess = (getTradeRecordGetOrderResponse200) & {
+    headers: Headers;
+};
+export type getTradeRecordGetOrderResponse = (getTradeRecordGetOrderResponseSuccess);
+export declare const getGetTradeRecordGetOrderUrl: (tradePlatform: string, order: number) => string;
+/**
+ * Single trade record by order ticket from the pump cache.
+ *
+ * Pump-cached lookup of one order. Wrapper-level failures (unknown
+ * ticket, cache miss) surface in the envelope's ManagerAPICode /
+ * ErrorCode pair — clients must branch on isError before dereferencing
+ * payload.
+ * @summary Get trade record (cached)
+ */
+export declare const getTradeRecordGetOrder: (tradePlatform: string, order: number, options?: RequestInit) => Promise<getTradeRecordGetOrderResponse>;
+export type postTradeCheckStopsResponse200 = {
+    data: BooleanApiResponse;
+    status: 200;
+};
+export type postTradeCheckStopsResponseSuccess = (postTradeCheckStopsResponse200) & {
+    headers: Headers;
+};
+export type postTradeCheckStopsResponse = (postTradeCheckStopsResponseSuccess);
+export declare const getPostTradeCheckStopsUrl: (tradePlatform: string, params?: PostTradeCheckStopsParams) => string;
+/**
+ * Validate an order's SL/TP/pending-open levels against the symbol's administrator-set `stops_level`.
+ *
+ * Pump-cached call. The MT4 server verifies that the supplied SL/TP
+ * (and, for pending orders, the open price) sit at least
+ * `stops_level` away from the current market and that pending
+ * expiration is at least ten minutes in the future. Returns a bare
+ * boolean envelope: `true` when the wrapper's `ResultCode`
+ * is `Ok`.
+ *
+ * Useful for client-side pre-flight before submitting a real
+ * `TradeTransaction` — saves a server round-trip for invalid
+ * orders.
+ * @summary Validate order stops
+ */
+export declare const postTradeCheckStops: (tradePlatform: string, mT4TradeTransaction?: MT4TradeTransaction, params?: PostTradeCheckStopsParams, options?: RequestInit) => Promise<postTradeCheckStopsResponse>;
+export type postTradeClearRollbackOrderResponse200 = {
+    data: BooleanApiResponse;
+    status: 200;
+};
+export type postTradeClearRollbackOrderResponseSuccess = (postTradeClearRollbackOrderResponse200) & {
+    headers: Headers;
+};
+export type postTradeClearRollbackOrderResponse = (postTradeClearRollbackOrderResponseSuccess);
+export declare const getPostTradeClearRollbackOrderUrl: (tradePlatform: string, order: number) => string;
+/**
+ * Roll back an in-flight trade transaction by ticket.
+ *
+ * Pump-cached call. Cancels a pending trade transaction that the
+ * MT4 server is still holding in the rollback buffer (e.g. an
+ * instant-execution requote that has not yet been confirmed). Has
+ * no effect once the transaction has been committed; returns the
+ * wrapper's `ResultCode` as part of the envelope on failure.
+ *
+ * Idempotent on already-committed/already-rolled-back tickets.
+ * @summary Roll back trade transaction
+ */
+export declare const postTradeClearRollbackOrder: (tradePlatform: string, order: number, options?: RequestInit) => Promise<postTradeClearRollbackOrderResponse>;
+export type getTradeRecordRequestOrderResponse200 = {
+    data: MT4TradeApiResponse;
+    status: 200;
+};
+export type getTradeRecordRequestOrderResponseSuccess = (getTradeRecordRequestOrderResponse200) & {
+    headers: Headers;
+};
+export type getTradeRecordRequestOrderResponse = (getTradeRecordRequestOrderResponseSuccess);
+export declare const getGetTradeRecordRequestOrderUrl: (tradePlatform: string, order: number) => string;
+/**
+ * Fresh-from-server fetch of a single trade record by ticket.
+ *
+ * Manager (live) counterpart to `TradeRecordGet`. Where the pump
+ * variant reads from local cache (may lag by milliseconds), this round-
+ * trips to the MT4 server every call — slower but authoritative.
+ * Useful for reconciliation, post-close ticket lookups (pump may have
+ * flushed), or any flow where the caller can tolerate the latency cost
+ * in exchange for guaranteed freshness. Returns NotFound envelope when
+ * the ticket does not exist on the server.
+ * @summary Get trade record (live)
+ */
+export declare const getTradeRecordRequestOrder: (tradePlatform: string, order: number, options?: RequestInit) => Promise<getTradeRecordRequestOrderResponse>;
+export type getTradesRequestResponse200 = {
+    data: MT4TradeListApiResponse;
+    status: 200;
+};
+export type getTradesRequestResponseSuccess = (getTradesRequestResponse200) & {
+    headers: Headers;
+};
+export type getTradesRequestResponse = (getTradesRequestResponseSuccess);
+export declare const getGetTradesRequestUrl: (tradePlatform: string, params?: GetTradesRequestParams) => string;
+/**
+ * Broad Manager-live trade query. Returns every trade visible to the authenticated manager, paged by ticket ascending.
+ *
+ * Manager (live) — each call hits the MT4 server. Designed as the
+ * "scan from scratch" counterpart to the pump variants
+ * (`TradesGetByMarket`, `TradesGetBySymbol`): pump reads are
+ * instant but limited to currently-open trades visible to the pump;
+ * this endpoint returns the full server-side set the manager can see.
+ * Heavy — paginate aggressively, prefer pump variants when freshness
+ * is not critical.
+ * @summary Query trades (live)
+ */
+export declare const getTradesRequest: (tradePlatform: string, params?: GetTradesRequestParams, options?: RequestInit) => Promise<getTradesRequestResponse>;
+export type postAdmTradeRecordModifyTicketResponse200 = {
+    data: MT4TradeApiResponse;
+    status: 200;
+};
+export type postAdmTradeRecordModifyTicketResponseSuccess = (postAdmTradeRecordModifyTicketResponse200) & {
+    headers: Headers;
+};
+export type postAdmTradeRecordModifyTicketResponse = (postAdmTradeRecordModifyTicketResponseSuccess);
+export declare const getPostAdmTradeRecordModifyTicketUrl: (tradePlatform: string, ticket: number) => string;
+/**
+ * Admin direct edit of a single trade record — Type 1 with read-first.
+ *
+ * <br>
+ * Low-level back-office override that writes directly to the trade
+ * record. For SL/TP edits prefer
+ * `POST TradeTransaction` with `tradeTransactionType=ModifyTrade`
+ * — that route goes through the wrapper's audited path. Use this
+ * endpoint for manual accounting corrections (commission/storage/taxes/
+ * profit, comment, magic) that the standard TradeTransaction path
+ * does not cover.
+ * <br>
+ * Flow: read existing trade via `TradeRecordsRequest`, patch the
+ * allow-listed fields in place, submit via `AdmTradeRecordModify`.
+ * Order/Login/Symbol/Volume/OpenPrice/OpenTime/CloseTime and gateway
+ * internals are preserved by virtue of not being on the input DTO.
+ * <br>
+ * Idempotency-Key strongly recommended. A retried edit without it can
+ * land twice — usually harmless, but generates audit log noise.
+ * @summary Modify trade record (admin)
+ */
+export declare const postAdmTradeRecordModifyTicket: (tradePlatform: string, ticket: number, mT4TradeUpdate?: MT4TradeUpdate, options?: RequestInit) => Promise<postAdmTradeRecordModifyTicketResponse>;
+export type postTradeTransactionResponse200 = {
+    data: MT4TradeTransactionApiResponse;
+    status: 200;
+};
+export type postTradeTransactionResponseSuccess = (postTradeTransactionResponse200) & {
+    headers: Headers;
+};
+export type postTradeTransactionResponse = (postTradeTransactionResponseSuccess);
+export declare const getPostTradeTransactionUrl: (tradePlatform: string) => string;
+/**
+ * Submit a trade transaction — open / modify / close / balance op.
+ *
+ * <br>
+ * POST mutator covering every wrapper trade operation through the single
+ * `TradeTransaction` entry point. The request body's
+ * `tradeTransactionType` + `tradeCommand` combination selects
+ * the actual operation (OpenPending+Buy, ModifyTrade, CloseMarket+Sell,
+ * BalanceAdd+Balance, etc).
+ * <br>
+ * On success the response echoes the wrapper's mutated structure — most
+ * importantly the `Order` field, which the server assigns on Open
+ * operations and clients use to track the ticket afterwards.
+ * <br><b>Idempotency-Key is essentially mandatory.</b> A retried trade
+ * transaction without the header can open a second position, double-
+ * close, or apply a balance op twice. With the header the second call
+ * returns the cached envelope from the first.
+ * @summary Submit trade transaction
+ */
+export declare const postTradeTransaction: (tradePlatform: string, mT4TradeTransaction?: MT4TradeTransaction, options?: RequestInit) => Promise<postTradeTransactionResponse>;
+export type getTradeRecordsRequestResponse200 = {
+    data: MT4TradeListApiResponse;
+    status: 200;
+};
+export type getTradeRecordsRequestResponseSuccess = (getTradeRecordsRequestResponse200) & {
+    headers: Headers;
+};
+export type getTradeRecordsRequestResponse = (getTradeRecordsRequestResponseSuccess);
+export declare const getGetTradeRecordsRequestUrl: (tradePlatform: string, params?: GetTradeRecordsRequestParams) => string;
+/**
+ * Trade records for a batch of order tickets — live round-trip.
+ *
+ * Manager (live) call. Pass tickets as repeated query parameters:
+ * `?orders=12345&orders=67890`. Server-side billing counts this
+ * as one Manager request regardless of array length — prefer this over
+ * looping single `TradeRecordGet` calls.
+ *
+ * Returns the trade records the server has for the requested tickets.
+ * Order in the response is NOT guaranteed to match the request order;
+ * missing tickets are silently omitted (the envelope is not an error
+ * envelope in that case — match by `order` field on the client).
+ * @summary Get trade records batch (live)
+ */
+export declare const getTradeRecordsRequest: (tradePlatform: string, params?: GetTradeRecordsRequestParams, options?: RequestInit) => Promise<getTradeRecordsRequestResponse>;
+export type getAdmTradesRequestGroupResponse200 = {
+    data: MT4TradeListApiResponse;
+    status: 200;
+};
+export type getAdmTradesRequestGroupResponseSuccess = (getAdmTradesRequestGroupResponse200) & {
+    headers: Headers;
+};
+export type getAdmTradesRequestGroupResponse = (getAdmTradesRequestGroupResponseSuccess);
+export declare const getGetAdmTradesRequestGroupUrl: (tradePlatform: string, group: string, params?: GetAdmTradesRequestGroupParams) => string;
+/**
+ * All trades belonging to accounts in a given group (admin scope).
+ *
+ * Manager (live) call. Returns trades for every account assigned to
+ * the given group. `openOnly=true` filters out closed trades on
+ * the server side. Pair with `Idempotency-Key` on retry — large
+ * groups can return substantial payloads.
+ * @summary List group trades (admin)
+ */
+export declare const getAdmTradesRequestGroup: (tradePlatform: string, group: string, params?: GetAdmTradesRequestGroupParams, options?: RequestInit) => Promise<getAdmTradesRequestGroupResponse>;
+export type postAdmTradesDeleteResponse200 = {
+    data: BooleanApiResponse;
+    status: 200;
+};
+export type postAdmTradesDeleteResponseSuccess = (postAdmTradesDeleteResponse200) & {
+    headers: Headers;
+};
+export type postAdmTradesDeleteResponse = (postAdmTradesDeleteResponseSuccess);
+export declare const getPostAdmTradesDeleteUrl: (tradePlatform: string, params?: PostAdmTradesDeleteParams) => string;
+/**
+ * Bulk-deletes a list of trade tickets (administrative scope). Used for cleanup after reconciliation mistakes, simulator state reset, or compliance-mandated removal.
+ *
+ * Manager-live POST. The wrapper accepts a flat `int[]` of order
+ * tickets and a count; we mirror the existing batched-int pattern
+ * (repeat `?orders=` per ticket — same convention as
+ * `UserRecordsRequest`'s `?logins=`). Empty arrays are
+ * rejected with Validation.
+ *
+ * **Destructive.** Each ticket in the array is removed from the
+ * server's trade table; this is not reversible from the API side.
+ * Pair with `Idempotency-Key` so retries don't re-process partial
+ * failures.
+ * @summary Delete trades (admin)
+ */
+export declare const postAdmTradesDelete: (tradePlatform: string, params?: PostAdmTradesDeleteParams, options?: RequestInit) => Promise<postAdmTradesDeleteResponse>;
+export type postTradesSyncStartResponse200 = {
+    data: BooleanApiResponse;
+    status: 200;
+};
+export type postTradesSyncStartResponseSuccess = (postTradesSyncStartResponse200) & {
+    headers: Headers;
+};
+export type postTradesSyncStartResponse = (postTradesSyncStartResponseSuccess);
+export declare const getPostTradesSyncStartUrl: (tradePlatform: string, params?: PostTradesSyncStartParams) => string;
+/**
+ * Opens a server-side incremental sync session for trade records modified at or after timestamp.
+ *
+ * Manager-live POST (modifies server-side session state). The
+ * follow-up `TradesSyncRead` drain is deferred under wine x64
+ * (see deferral note in the Users section above). Pass
+ * `timestamp=0` to request all trades. The timestamp is Unix
+ * epoch seconds (int32) in MT4 server-local time, not UTC.
+ * @summary Start trade-records sync
+ */
+export declare const postTradesSyncStart: (tradePlatform: string, params?: PostTradesSyncStartParams, options?: RequestInit) => Promise<postTradesSyncStartResponse>;