@mywebapi.com/sdk 0.1.2 → 0.3.0

package/dist/node/index.js

@@ -0,0 +1,4664 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/deadline.ts
+async function withDeadline(timeoutMs, caller, operation) {
+  const controller = new AbortController;
+  let completed = false;
+  const timer = setTimeout(() => {
+    if (!completed)
+      controller.abort(new DOMException("The operation timed out.", "TimeoutError"));
+  }, timeoutMs);
+  const operationSignal = caller ? AbortSignal.any([caller, controller.signal]) : controller.signal;
+  try {
+    return await operation(operationSignal);
+  } finally {
+    completed = true;
+    clearTimeout(timer);
+  }
+}
+
+// src/auth.ts
+class StaticTokenProvider {
+  token;
+  constructor(token) {
+    this.token = token;
+  }
+  async getToken(_opts) {
+    return this.token;
+  }
+}
+
+class OAuth2TokenError extends Error {
+  status;
+  errorCode;
+  errorDescription;
+  requestId;
+  constructor(opts) {
+    const code = opts.errorCode ?? String(opts.status);
+    const desc = opts.errorDescription ?? "<no description>";
+    super("OAuth2 token error (" + code + "): " + desc);
+    this.name = "OAuth2TokenError";
+    this.status = opts.status;
+    this.errorCode = opts.errorCode;
+    this.errorDescription = opts.errorDescription;
+    this.requestId = opts.requestId;
+  }
+}
+
+class ClientCredentialsTokenProvider {
+  clientId;
+  clientSecret;
+  identityUrl;
+  identityOrigin;
+  scopes;
+  fetchFn;
+  clockSkewMs;
+  timeoutMs;
+  allowInsecureLoopback;
+  cached = null;
+  discoveryPromise = null;
+  refreshPromise = null;
+  constructor(opts) {
+    this.clientId = opts.clientId;
+    this.clientSecret = opts.clientSecret;
+    this.allowInsecureLoopback = opts.allowInsecureLoopback === true;
+    this.identityUrl = stripTrailingSlashes(validateHttpsUrl(opts.identityUrl, "identityUrl", this.allowInsecureLoopback));
+    this.identityOrigin = new URL(this.identityUrl).origin;
+    this.scopes = opts.scopes;
+    this.fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
+    this.clockSkewMs = (opts.clockSkewSeconds ?? 60) * 1000;
+    this.timeoutMs = opts.timeoutMs ?? 30000;
+    if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
+      throw new TypeError("timeoutMs must be a positive finite number");
+    }
+  }
+  async getToken(opts) {
+    if (!opts?.forceRefresh && this.cached && this.cached.expiresAt - Date.now() > this.clockSkewMs) {
+      return this.cached.accessToken;
+    }
+    let refresh = this.refreshPromise;
+    if (!refresh) {
+      refresh = this.acquireToken();
+      this.refreshPromise = refresh;
+      refresh.then((result2) => {
+        this.cached = result2;
+        if (this.refreshPromise === refresh)
+          this.refreshPromise = null;
+      }, () => {
+        if (this.refreshPromise === refresh)
+          this.refreshPromise = null;
+      });
+    }
+    const result = await waitForAbortable(refresh, opts?.signal);
+    return result.accessToken;
+  }
+  async acquireToken() {
+    const { tokenEndpoint } = await this.getDiscovery();
+    const body = new URLSearchParams;
+    body.set("grant_type", "client_credentials");
+    body.set("client_id", this.clientId);
+    body.set("client_secret", this.clientSecret);
+    if (this.scopes && this.scopes.length > 0)
+      body.set("scope", this.scopes.join(" "));
+    return withDeadline(this.timeoutMs, undefined, async (signal) => {
+      const res = await this.fetchFn(tokenEndpoint, {
+        method: "POST",
+        redirect: "error",
+        signal,
+        headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+        body: body.toString()
+      });
+      const requestId = res.headers.get("x-request-id") ?? undefined;
+      if (!res.ok) {
+        const errorPayload = await parseOAuthError(res);
+        throw new OAuth2TokenError({
+          status: res.status,
+          ...errorPayload.errorCode !== undefined ? { errorCode: errorPayload.errorCode } : {},
+          ...errorPayload.errorDescription !== undefined ? { errorDescription: errorPayload.errorDescription } : {},
+          ...requestId !== undefined ? { requestId } : {}
+        });
+      }
+      const json = await res.json();
+      if (typeof json.access_token !== "string" || typeof json.expires_in !== "number" || json.expires_in <= 0) {
+        throw new OAuth2TokenError({
+          status: res.status,
+          errorCode: "invalid_response",
+          errorDescription: "Token endpoint returned malformed JSON (missing access_token or expires_in).",
+          ...requestId !== undefined ? { requestId } : {}
+        });
+      }
+      return { accessToken: json.access_token, expiresAt: Date.now() + json.expires_in * 1000 };
+    });
+  }
+  async getDiscovery() {
+    if (!this.discoveryPromise) {
+      const discovery = this.fetchDiscovery();
+      this.discoveryPromise = discovery;
+      discovery.then(() => {
+        return;
+      }, () => {
+        if (this.discoveryPromise === discovery)
+          this.discoveryPromise = null;
+      });
+    }
+    return this.discoveryPromise;
+  }
+  async fetchDiscovery() {
+    const url = this.identityUrl + "/.well-known/openid-configuration";
+    return withDeadline(this.timeoutMs, undefined, async (signal) => {
+      const res = await this.fetchFn(url, {
+        method: "GET",
+        redirect: "error",
+        signal,
+        headers: { Accept: "application/json" }
+      });
+      if (!res.ok) {
+        throw new OAuth2TokenError({
+          status: res.status,
+          errorCode: "discovery_failed",
+          errorDescription: "Discovery endpoint returned HTTP " + res.status + "."
+        });
+      }
+      const json = await res.json();
+      if (typeof json.token_endpoint !== "string") {
+        throw new OAuth2TokenError({
+          status: res.status,
+          errorCode: "discovery_invalid",
+          errorDescription: "Discovery document missing or invalid token_endpoint."
+        });
+      }
+      const tokenEndpoint = validateHttpsUrl(json.token_endpoint, "token_endpoint", this.allowInsecureLoopback);
+      if (new URL(tokenEndpoint).origin !== this.identityOrigin) {
+        throw new OAuth2TokenError({
+          status: res.status,
+          errorCode: "discovery_invalid",
+          errorDescription: "Discovery token_endpoint must use the identityUrl origin."
+        });
+      }
+      return { tokenEndpoint };
+    });
+  }
+}
+function stripTrailingSlashes(value) {
+  let result = value;
+  while (result.endsWith("/"))
+    result = result.slice(0, -1);
+  return result;
+}
+function validateHttpsUrl(raw, name, allowInsecureLoopback = false) {
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new TypeError(name + " must be an absolute URL");
+  }
+  const loopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+  if (parsed.protocol !== "https:" && !(allowInsecureLoopback && loopback && parsed.protocol === "http:")) {
+    throw new TypeError(name + " must use HTTPS (HTTP is allowed only for explicit loopback tests)");
+  }
+  if (parsed.username || parsed.password)
+    throw new TypeError(name + " must not contain credentials");
+  return stripTrailingSlashes(parsed.toString());
+}
+function waitForAbortable(promise, signal) {
+  if (!signal)
+    return promise;
+  const waitSignal = AbortSignal.any([signal]);
+  if (waitSignal.aborted)
+    return Promise.reject(waitSignal.reason ?? new DOMException("Aborted", "AbortError"));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(waitSignal.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    const cleanup = () => waitSignal.removeEventListener("abort", onAbort);
+    waitSignal.addEventListener("abort", onAbort, { once: true });
+    promise.then((value) => {
+      cleanup();
+      resolve(value);
+    }, (error) => {
+      cleanup();
+      reject(error);
+    });
+  });
+}
+async function parseOAuthError(res) {
+  const text = await res.text();
+  if (!text)
+    return {};
+  try {
+    const json = JSON.parse(text);
+    const out = {};
+    if (typeof json.error === "string")
+      out.errorCode = json.error;
+    if (typeof json.error_description === "string")
+      out.errorDescription = json.error_description;
+    if (out.errorCode || out.errorDescription)
+      return out;
+  } catch {}
+  const excerpt = text.slice(0, 500).replace(/client_secret=[^&\s]*/gi, "client_secret=<redacted>");
+  return { errorDescription: excerpt };
+}
+
+// src/environments.ts
+var PRESETS = {
+  prod: { apiBaseUrl: "https://cloud.mywebapi.com", authority: "https://auth.cplugin.net" },
+  staging: { apiBaseUrl: "https://pre.mywebapi.com", authority: "https://pre.auth.cplugin.net" }
+};
+function stripTrailingSlashes2(value) {
+  let result = value;
+  while (result.endsWith("/"))
+    result = result.slice(0, -1);
+  return result;
+}
+function validateServiceUrl(raw, name, allowInsecureLoopback = false) {
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new TypeError(name + " must be an absolute URL");
+  }
+  const loopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+  if (parsed.protocol !== "https:" && !(allowInsecureLoopback && loopback && parsed.protocol === "http:")) {
+    throw new TypeError(name + " must use HTTPS (HTTP is allowed only for explicit loopback tests)");
+  }
+  if (parsed.username || parsed.password)
+    throw new TypeError(name + " must not contain credentials");
+  return stripTrailingSlashes2(parsed.toString());
+}
+function resolveEnvironment(sel) {
+  if (sel.env === "custom") {
+    const allowInsecureLoopback = sel.allowInsecureLoopback === true;
+    return {
+      apiBaseUrl: validateServiceUrl(sel.apiBaseUrl, "apiBaseUrl", allowInsecureLoopback),
+      authority: validateServiceUrl(sel.authority, "authority", allowInsecureLoopback),
+      ...allowInsecureLoopback ? { allowInsecureLoopback: true } : {}
+    };
+  }
+  const preset = PRESETS[sel.env];
+  return { ...preset };
+}
+
+// src/signalr.ts
+class MT4V2SignalRError extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "MT4V2SignalRError";
+  }
+}
+
+class MT4V2SignalRClient {
+  hubUrl;
+  tokenProvider;
+  reconnect;
+  logger;
+  connection = null;
+  pendingHandlers = [];
+  constructor(opts) {
+    if (!opts.tradePlatform)
+      throw new MT4V2SignalRError("tradePlatform is required");
+    if (!opts.baseUrl)
+      throw new MT4V2SignalRError("baseUrl is required");
+    if ("tokenProvider" in opts && opts.tokenProvider) {
+      this.tokenProvider = opts.tokenProvider;
+    } else if ("token" in opts && opts.token) {
+      this.tokenProvider = new StaticTokenProvider(opts.token);
+    } else if ("clientId" in opts && "clientSecret" in opts && "identityUrl" in opts) {
+      const cco = {
+        clientId: opts.clientId,
+        clientSecret: opts.clientSecret,
+        identityUrl: opts.identityUrl,
+        ...opts.scopes ? { scopes: opts.scopes } : {},
+        ...opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {},
+        ...opts.allowInsecureLoopback ? { allowInsecureLoopback: true } : {}
+      };
+      this.tokenProvider = new ClientCredentialsTokenProvider(cco);
+    } else {
+      throw new MT4V2SignalRError("opts must include either `tokenProvider`, `token`, or { clientId, clientSecret, identityUrl }");
+    }
+    const allowInsecureLoopback = opts.allowInsecureLoopback === true;
+    const serviceBase = validateServiceUrl(opts.baseUrl, "baseUrl", allowInsecureLoopback);
+    const base = validateServiceUrl(opts.hubUrl ?? `${serviceBase}/hubs/mt4/v2`, "hubUrl", allowInsecureLoopback);
+    const sep = base.includes("?") ? "&" : "?";
+    this.hubUrl = `${base}${sep}tradePlatform=${encodeURIComponent(opts.tradePlatform)}`;
+    this.reconnect = opts.reconnect ?? [0, 2000, 1e4, 30000];
+    this.logger = opts.logger;
+  }
+  register(fn) {
+    if (this.connection) {
+      fn(this.connection);
+    } else {
+      this.pendingHandlers.push(fn);
+    }
+  }
+  get hubUrlForTest() {
+    return this.hubUrl;
+  }
+  tokenForTest() {
+    return this.tokenProvider.getToken();
+  }
+  async loadSignalRModule() {
+    try {
+      return await import("@microsoft/signalr");
+    } catch (e) {
+      throw new MT4V2SignalRError("The required `@microsoft/signalr` dependency could not be loaded. Run `npm install @microsoft/signalr` (or `bun add @microsoft/signalr`) and retry.", e);
+    }
+  }
+  async start() {
+    if (this.connection?.state === "Connected")
+      return;
+    const signalR = await this.loadSignalRModule();
+    const Builder = signalR.HubConnectionBuilder;
+    const LogLevel = signalR.LogLevel;
+    let builder = new Builder().withUrl(this.hubUrl, {
+      accessTokenFactory: () => this.tokenProvider.getToken()
+    });
+    if (this.reconnect !== false) {
+      builder = builder.withAutomaticReconnect(this.reconnect);
+    }
+    if (this.logger !== undefined) {
+      builder = builder.configureLogging(this.logger);
+    } else {
+      builder = builder.configureLogging(LogLevel.Warning);
+    }
+    const conn = builder.build();
+    this.connection = conn;
+    for (const fn of this.pendingHandlers)
+      fn(conn);
+    this.pendingHandlers = [];
+    conn.on("OnConnectionStatus", () => {});
+    await conn.start();
+  }
+  async stop() {
+    if (!this.connection)
+      return;
+    await this.connection.stop();
+    this.connection = null;
+  }
+  getConnection() {
+    if (!this.connection)
+      throw new MT4V2SignalRError("SignalR client not started — call start() first");
+    return this.connection;
+  }
+  onTick(handler) {
+    this.register((c) => c.on("OnTick", handler));
+  }
+  onConnectionStatus(handler) {
+    this.register((c) => c.on("OnConnectionStatus", handler));
+  }
+  async subscribeToTicks(symbol) {
+    await this.getConnection().invoke("SubscribeToTicks", symbol);
+  }
+  async unsubscribeFromTicks(symbol) {
+    await this.getConnection().invoke("UnsubscribeFromTicks", symbol);
+  }
+  streamTicks(symbol) {
+    const conn = this.getConnection();
+    const args = symbol !== undefined ? [symbol] : [];
+    return this.toAsyncIterable(conn.stream("StreamTicks", ...args));
+  }
+  streamMarginCallUpdates() {
+    const conn = this.getConnection();
+    return this.toAsyncIterable(conn.stream("StreamMarginCallUpdates"));
+  }
+  streamTrades() {
+    const conn = this.getConnection();
+    return this.toAsyncIterable(conn.stream("StreamTrades"));
+  }
+  streamUserUpdates() {
+    const conn = this.getConnection();
+    return this.toAsyncIterable(conn.stream("StreamUserUpdates"));
+  }
+  streamSymbolUpdates() {
+    const conn = this.getConnection();
+    return this.toAsyncIterable(conn.stream("StreamSymbolUpdates"));
+  }
+  toAsyncIterable(stream) {
+    return {
+      [Symbol.asyncIterator]() {
+        const queue = [];
+        let waiter = null;
+        let error = null;
+        let done = false;
+        let sub = null;
+        sub = stream.subscribe({
+          next: (item) => {
+            if (done)
+              return;
+            if (waiter) {
+              const current = waiter;
+              waiter = null;
+              current.resolve({ value: item, done: false });
+            } else {
+              queue.push(item);
+            }
+          },
+          complete: () => {
+            if (done)
+              return;
+            done = true;
+            if (waiter) {
+              const current = waiter;
+              waiter = null;
+              current.resolve({ value: undefined, done: true });
+            }
+          },
+          error: (reason) => {
+            if (done)
+              return;
+            error = reason;
+            done = true;
+            sub?.dispose();
+            if (waiter) {
+              const current = waiter;
+              waiter = null;
+              current.reject(reason);
+            }
+          }
+        });
+        return {
+          next() {
+            if (error !== null)
+              return Promise.reject(error);
+            if (queue.length)
+              return Promise.resolve({ value: queue.shift(), done: false });
+            if (done)
+              return Promise.resolve({ value: undefined, done: true });
+            return new Promise((resolve, reject) => {
+              waiter = { resolve, reject };
+            });
+          },
+          return() {
+            try {
+              sub?.dispose();
+            } catch {}
+            done = true;
+            if (waiter) {
+              const current = waiter;
+              waiter = null;
+              current.resolve({ value: undefined, done: true });
+            }
+            return Promise.resolve({ value: undefined, done: true });
+          }
+        };
+      }
+    };
+  }
+}
+
+// src/signalr.mt5.ts
+class MT5V2SignalRClient {
+  hubUrl;
+  tokenProvider;
+  reconnect;
+  logger;
+  connection = null;
+  pendingHandlers = [];
+  constructor(opts) {
+    if (!opts.tradePlatform)
+      throw new MT4V2SignalRError("tradePlatform is required");
+    if (!opts.baseUrl)
+      throw new MT4V2SignalRError("baseUrl is required");
+    if ("tokenProvider" in opts && opts.tokenProvider) {
+      this.tokenProvider = opts.tokenProvider;
+    } else if ("token" in opts && opts.token) {
+      this.tokenProvider = new StaticTokenProvider(opts.token);
+    } else if ("clientId" in opts && "clientSecret" in opts && "identityUrl" in opts) {
+      const cco = {
+        clientId: opts.clientId,
+        clientSecret: opts.clientSecret,
+        identityUrl: opts.identityUrl,
+        ...opts.scopes ? { scopes: opts.scopes } : {},
+        ...opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {},
+        ...opts.allowInsecureLoopback ? { allowInsecureLoopback: true } : {}
+      };
+      this.tokenProvider = new ClientCredentialsTokenProvider(cco);
+    } else {
+      throw new MT4V2SignalRError("opts must include either `tokenProvider`, `token`, or { clientId, clientSecret, identityUrl }");
+    }
+    const allowInsecureLoopback = opts.allowInsecureLoopback === true;
+    const serviceBase = validateServiceUrl(opts.baseUrl, "baseUrl", allowInsecureLoopback);
+    const base = validateServiceUrl(opts.hubUrl ?? `${serviceBase}/hubs/mt5/v2`, "hubUrl", allowInsecureLoopback);
+    const sep = base.includes("?") ? "&" : "?";
+    this.hubUrl = `${base}${sep}tradePlatform=${encodeURIComponent(opts.tradePlatform)}`;
+    this.reconnect = opts.reconnect ?? [0, 2000, 1e4, 30000];
+    this.logger = opts.logger;
+  }
+  register(fn) {
+    if (this.connection) {
+      fn(this.connection);
+    } else {
+      this.pendingHandlers.push(fn);
+    }
+  }
+  get hubUrlForTest() {
+    return this.hubUrl;
+  }
+  tokenForTest() {
+    return this.tokenProvider.getToken();
+  }
+  async loadSignalRModule() {
+    try {
+      return await import("@microsoft/signalr");
+    } catch (e) {
+      throw new MT4V2SignalRError("The required `@microsoft/signalr` dependency could not be loaded. Run `npm install @microsoft/signalr` (or `bun add @microsoft/signalr`) and retry.", e);
+    }
+  }
+  async start() {
+    if (this.connection?.state === "Connected")
+      return;
+    const signalR = await this.loadSignalRModule();
+    const Builder = signalR.HubConnectionBuilder;
+    const LogLevel = signalR.LogLevel;
+    let builder = new Builder().withUrl(this.hubUrl, {
+      accessTokenFactory: () => this.tokenProvider.getToken()
+    });
+    if (this.reconnect !== false) {
+      builder = builder.withAutomaticReconnect(this.reconnect);
+    }
+    if (this.logger !== undefined) {
+      builder = builder.configureLogging(this.logger);
+    } else {
+      builder = builder.configureLogging(LogLevel.Warning);
+    }
+    const conn = builder.build();
+    this.connection = conn;
+    for (const fn of this.pendingHandlers)
+      fn(conn);
+    this.pendingHandlers = [];
+    conn.on("OnConnectionStatus", () => {});
+    await conn.start();
+  }
+  async stop() {
+    if (!this.connection)
+      return;
+    await this.connection.stop();
+    this.connection = null;
+  }
+  getConnection() {
+    if (!this.connection)
+      throw new MT4V2SignalRError("SignalR client not started — call start() first");
+    return this.connection;
+  }
+  onConnectionStatus(handler) {
+    this.register((c) => c.on("OnConnectionStatus", handler));
+  }
+  streamMarginCallUpdates() {
+    return this.toAsyncIterable(this.getConnection().stream("StreamMarginCallUpdates"));
+  }
+  toAsyncIterable(stream) {
+    return {
+      [Symbol.asyncIterator]() {
+        const queue = [];
+        let waiter = null;
+        let error = null;
+        let done = false;
+        let sub = null;
+        sub = stream.subscribe({
+          next: (item) => {
+            if (done)
+              return;
+            if (waiter) {
+              const current = waiter;
+              waiter = null;
+              current.resolve({ value: item, done: false });
+            } else {
+              queue.push(item);
+            }
+          },
+          complete: () => {
+            if (done)
+              return;
+            done = true;
+            if (waiter) {
+              const current = waiter;
+              waiter = null;
+              current.resolve({ value: undefined, done: true });
+            }
+          },
+          error: (reason) => {
+            if (done)
+              return;
+            error = reason;
+            done = true;
+            sub?.dispose();
+            if (waiter) {
+              const current = waiter;
+              waiter = null;
+              current.reject(reason);
+            }
+          }
+        });
+        return {
+          next() {
+            if (error !== null)
+              return Promise.reject(error);
+            if (queue.length)
+              return Promise.resolve({ value: queue.shift(), done: false });
+            if (done)
+              return Promise.resolve({ value: undefined, done: true });
+            return new Promise((resolve, reject) => {
+              waiter = { resolve, reject };
+            });
+          },
+          return() {
+            try {
+              sub?.dispose();
+            } catch {}
+            done = true;
+            if (waiter) {
+              const current = waiter;
+              waiter = null;
+              current.resolve({ value: undefined, done: true });
+            }
+            return Promise.resolve({ value: undefined, done: true });
+          }
+        };
+      }
+    };
+  }
+}
+
+// src/retry.ts
+var defaultPolicy = {
+  maxAttempts: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 1e4,
+  factor: 2,
+  jitterPercent: 0.25
+};
+var RETRYABLE_STATUSES = new Set([408, 429, 502, 503, 504]);
+async function withRetry(op, opts) {
+  const policy = opts.policy ?? defaultPolicy;
+  const { isIdempotent, signal } = opts;
+  let attempt = 0;
+  let lastResponse = null;
+  let lastError = null;
+  while (attempt < policy.maxAttempts) {
+    attempt++;
+    throwIfAborted(signal);
+    let outcome = null;
+    let thrown = null;
+    try {
+      outcome = await op();
+    } catch (error) {
+      thrown = error;
+    }
+    if (outcome) {
+      lastResponse = outcome;
+      lastError = null;
+      if (!shouldRetryStatus(outcome.response.status, isIdempotent))
+        return outcome;
+    } else {
+      lastError = thrown;
+      lastResponse = null;
+      if (!isIdempotent || isAbortLike(thrown) || signal?.aborted)
+        break;
+    }
+    if (attempt >= policy.maxAttempts)
+      break;
+    await sleep(computeDelayMs({ attempt, policy, response: outcome?.response }), signal);
+  }
+  if (lastResponse)
+    return lastResponse;
+  throw lastError;
+}
+function isAbortLike(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const value = error;
+  return value.name === "AbortError" || value.name === "TimeoutError" || value.code === "ABORT_ERR";
+}
+function shouldRetryStatus(status, isIdempotent) {
+  return isIdempotent && RETRYABLE_STATUSES.has(status);
+}
+function computeDelayMs(args) {
+  const { attempt, policy, response } = args;
+  if (response) {
+    const retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
+    if (retryAfterMs !== null)
+      return Math.min(retryAfterMs, policy.maxDelayMs);
+  }
+  const exp = policy.baseDelayMs * Math.pow(policy.factor, attempt - 1);
+  const capped = Math.min(exp, policy.maxDelayMs);
+  const jitter = (Math.random() - 0.5) * 2 * policy.jitterPercent;
+  return Math.max(0, capped * (1 + jitter));
+}
+function parseRetryAfter(header) {
+  if (!header)
+    return null;
+  const trimmed = header.trim();
+  if (trimmed === "")
+    return null;
+  if (/^\d+$/.test(trimmed))
+    return Number(trimmed) * 1000;
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date))
+    return null;
+  return Math.max(0, date - Date.now());
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted)
+    return;
+  throw signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+function sleep(ms, signal) {
+  if (ms <= 0) {
+    throwIfAborted(signal);
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    let timer;
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    if (signal) {
+      if (signal.aborted)
+        onAbort();
+      else
+        signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+
+// src/mutator.context.ts
+var requestContext = Symbol("cplugin.webapi.request-context");
+function contextFromOptions(options) {
+  const ctx = options[requestContext];
+  if (!ctx)
+    throw new Error("No request context: call generated methods via CPluginWebApiClient.");
+  return ctx;
+}
+function withRequestContext(options, ctx) {
+  return { ...options ?? {}, [requestContext]: ctx };
+}
+var responseMeta = Symbol("cplugin.webapi.response-meta");
+
+// src/errors.ts
+var REQUEST_OUTCOMES = new Set(["timeout", "unknown", "not-started", "in-progress"]);
+function parseRequestOutcome(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized && REQUEST_OUTCOMES.has(normalized) ? normalized : undefined;
+}
+function codeForHttpStatus(status) {
+  if (status === 401 || status === 403)
+    return "Forbidden";
+  if (status === 404)
+    return "NotFound";
+  return "Internal";
+}
+
+class ApiError extends Error {
+  code;
+  description;
+  activityId;
+  managerCode;
+  status;
+  outcome;
+  appliedTimeout;
+  constructor(body, meta, status, details) {
+    const desc = body.message ?? undefined;
+    super(desc ?? `v2 error: ${body.code}`);
+    this.name = "ApiError";
+    this.code = body.code;
+    this.description = desc;
+    this.activityId = meta?.activityId ?? undefined;
+    this.managerCode = body.managerCode ?? undefined;
+    this.status = status;
+    this.outcome = details?.outcome;
+    this.appliedTimeout = details?.appliedTimeout;
+  }
+}
+function isOutcomeUnknown(error) {
+  return error instanceof ApiError && reportsOutcomeUnknown(error);
+}
+function reportsOutcomeUnknown(error) {
+  return error.code === "OutcomeUnknown" || error.outcome === "unknown" || error.outcome === "in-progress";
+}
+function isRetryable(error) {
+  if (!(error instanceof ApiError) || reportsOutcomeUnknown(error))
+    return false;
+  return error.code === "Busy" || error.code === "Timeout" || error.outcome === "not-started" || error.outcome === "timeout";
+}
+
+// src/request-timeouts.generated.ts
+var REQUEST_TIMEOUT_MIN_SECONDS = 1;
+var REQUEST_TIMEOUT_MAX_SECONDS = 300;
+var OPERATION_TIMEOUTS = [
+  ["GET", "/api/v2/MT4/{tradePlatform}/AdmBalanceCheck", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/AdmBalanceCheck/{login}", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/AdmBalanceFix", 5],
+  ["POST", "/api/v2/MT4/{tradePlatform}/AdmTradeRecordModify/{ticket}", 5],
+  ["POST", "/api/v2/MT4/{tradePlatform}/AdmTradesDelete", 5],
+  ["GET", "/api/v2/MT4/{tradePlatform}/AdmTradesRequest/{group}", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/AdmUsersRequestSafe/{group}", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/BackupInfoOrders/{mode}", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/BackupInfoUsers/{mode}", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/BackupRequestOrders/{file}", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/BackupRequestUsers/{file}", 30],
+  ["POST", "/api/v2/MT4/{tradePlatform}/BackupRestoreOrders", 60],
+  ["POST", "/api/v2/MT4/{tradePlatform}/BackupRestoreUsers", 60],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteAccess/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteDataServer/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteFeeder/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteGatewayAccount/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteGatewayMarkup/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteGatewayRule/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteHoliday/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteLiveUpdate/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteManager/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteSymbol/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgDeleteSync/{pos}", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestAccess", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestBackup", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestCommon", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestDataServer", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestFeeder", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestGatewayAccount", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestGatewayMarkup", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestGatewayRule", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestHoliday", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestLiveUpdate", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestManager", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestPlugin", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestSymbol", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestSymbol/{symbol}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestSync", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/CfgRequestTime", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftAccess/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftDataServer/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftFeeder/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftGatewayAccount/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftGatewayMarkup/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftGatewayRule/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftGroup/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftHoliday/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftLiveUpdate/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftManager/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftPlugin/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftSymbol/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgShiftSync/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateAccess/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateBackup", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateCommon", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateDataServer/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateFeeder", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateGatewayAccount", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateGatewayMarkup", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateGatewayRule", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateHoliday/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateLiveUpdate", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateManager", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdatePlugin", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateSymbol/{symbol}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateSymbolGroup/{pos}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateSync", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/CfgUpdateTime", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/ChartAdd/{symbol}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/ChartDelete/{symbol}", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/ChartRequest/{symbol}", 30],
+  ["POST", "/api/v2/MT4/{tradePlatform}/ChartUpdate/{symbol}", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/DailyReportsRequest", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/DailyReportsRequestEx", 30],
+  ["POST", "/api/v2/MT4/{tradePlatform}/DailySyncRead", 30],
+  ["POST", "/api/v2/MT4/{tradePlatform}/DailySyncStart", 60],
+  ["GET", "/api/v2/MT4/{tradePlatform}/EnsureGroupNameExist/{group}", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/ExternalCommandBinary", 60],
+  ["POST", "/api/v2/MT4/{tradePlatform}/ExternalCommandJSON", 60],
+  ["PATCH", "/api/v2/MT4/{tradePlatform}/GroupRecord/{group}", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/GroupRecordGet/{group}", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/GroupRecordUpdate/{group}", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/GroupSecGroupsGet/{group}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/GroupSecMarginsGet/{group}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/GroupsGet", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/GroupsRequest", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/HistoryCorrect/{symbol}", 60],
+  ["GET", "/api/v2/MT4/{tradePlatform}/JournalRequest", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/LicenseCheck/{licenseName}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/MailLast", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/MailSend", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/MailsRequest", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/ManagerCommon", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/MarginLevelGet/{login}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/MarginLevelRequest/{login}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/MarginsGet", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/NewsBodyGet/{key}", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/NewsBodyRequest/{key}", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/NewsGet", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/NewsSend", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/NewsTopicGet/{pos}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/NewsTotal", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/NotificationsSend", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/OnlineGet", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/OnlineRequest", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/PerformanceRequest", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/PluginParamGet/{pos}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/PluginsGet", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/PluginUpdate", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/ReportsRequest", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/ServerTime", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/SrvChartsSync", 60],
+  ["GET", "/api/v2/MT4/{tradePlatform}/SrvFeederLog/{name}", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/SrvFeeders", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/SrvFeedsRestart", 60],
+  ["POST", "/api/v2/MT4/{tradePlatform}/SrvLiveUpdateStart", 60],
+  ["POST", "/api/v2/MT4/{tradePlatform}/SrvRestart", 60],
+  ["POST", "/api/v2/MT4/{tradePlatform}/SymbolAdd/{symbol}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/SymbolChange", 15],
+  ["PATCH", "/api/v2/MT4/{tradePlatform}/SymbolConfig/{symbol}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/SymbolHide/{symbol}", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/SymbolInfoGet", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/SymbolInfoUpdated", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/SymbolSendTick", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/SymbolSessionsGet/{symbol}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/SymbolsGroupsGet", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/SymbolsRefresh", 60],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TickInfoLast", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TickInfoLast/{symbol}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TicksRequest/{symbol}", 30],
+  ["POST", "/api/v2/MT4/{tradePlatform}/TradeCheckStops", 5],
+  ["POST", "/api/v2/MT4/{tradePlatform}/TradeClearRollback/{order}", 5],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradeRecordGet/{order}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradeRecordRequest/{order}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradeRecordsRequest", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradesGet", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradesGet/{ticket}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradesGetByLogin/{login}/{group}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradesGetByMarket", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradesGetBySymbol", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradesRequest", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradesSnapshot", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradesSyncRead", 30],
+  ["POST", "/api/v2/MT4/{tradePlatform}/TradesSyncStart", 60],
+  ["GET", "/api/v2/MT4/{tradePlatform}/TradesUserHistory/{login}", 30],
+  ["POST", "/api/v2/MT4/{tradePlatform}/TradeTransaction", 5],
+  ["POST", "/api/v2/MT4/{tradePlatform}/UserPasswordCheck/{login}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/UserPasswordSet/{login}", 15],
+  ["PATCH", "/api/v2/MT4/{tradePlatform}/UserRecord/{login}", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/UserRecordGet/{login}", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/UserRecordNew", 15],
+  ["GET", "/api/v2/MT4/{tradePlatform}/UserRecordRequest/{login}", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/UserRecordsRequest", 10],
+  ["POST", "/api/v2/MT4/{tradePlatform}/UserRecordUpdate/{login}", 15],
+  ["POST", "/api/v2/MT4/{tradePlatform}/UsersGroupOp", 60],
+  ["GET", "/api/v2/MT4/{tradePlatform}/UsersRequest", 10],
+  ["GET", "/api/v2/MT4/{tradePlatform}/UsersSnapshot", 30],
+  ["GET", "/api/v2/MT4/{tradePlatform}/UsersSyncRead", 30],
+  ["POST", "/api/v2/MT4/{tradePlatform}/UsersSyncStart", 60],
+  ["GET", "/api/v2/MT5/{tradePlatform}/DealByGroup/{mask}", 30],
+  ["GET", "/api/v2/MT5/{tradePlatform}/GroupGet/{group}", 10],
+  ["PATCH", "/api/v2/MT5/{tradePlatform}/GroupRecord/{group}", 15],
+  ["GET", "/api/v2/MT5/{tradePlatform}/ManagerCurrent", 10],
+  ["GET", "/api/v2/MT5/{tradePlatform}/OrderByGroup/{mask}", 10],
+  ["GET", "/api/v2/MT5/{tradePlatform}/PositionByGroup/{mask}", 10],
+  ["GET", "/api/v2/MT5/{tradePlatform}/ServerTime", 10],
+  ["GET", "/api/v2/MT5/{tradePlatform}/SymbolGet/{symbol}", 10],
+  ["PATCH", "/api/v2/MT5/{tradePlatform}/SymbolRecord/{symbol}", 15],
+  ["GET", "/api/v2/MT5/{tradePlatform}/TimeGet", 10],
+  ["GET", "/api/v2/MT5/{tradePlatform}/UserGet/{login}", 10],
+  ["PATCH", "/api/v2/MT5/{tradePlatform}/UserRecord/{login}", 15]
+];
+
+// src/request-timeout.ts
+var REQUEST_TIMEOUT_HEADER = "X-Request-Timeout";
+var REQUEST_TIMEOUT_QUERY = "requestTimeout";
+var REQUEST_TIMEOUT_APPLIED_HEADER = "X-Request-Timeout-Applied";
+var REQUEST_OUTCOME_HEADER = "X-Request-Outcome";
+var SERVER_ANSWER_MARGIN_MS = 30000;
+function validateRequestTimeout(seconds, name = "requestTimeout") {
+  if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < REQUEST_TIMEOUT_MIN_SECONDS || seconds > REQUEST_TIMEOUT_MAX_SECONDS) {
+    throw new TypeError(`${name} must be a number of seconds from ${REQUEST_TIMEOUT_MIN_SECONDS} to ${REQUEST_TIMEOUT_MAX_SECONDS}`);
+  }
+  return seconds;
+}
+var ROUTES = new Map;
+for (const [method, path, seconds] of OPERATION_TIMEOUTS) {
+  const segments = path.split("/").filter(Boolean).map((s) => s.startsWith("{") ? null : s.toLowerCase());
+  const list = ROUTES.get(method) ?? [];
+  list.push({ segments, staticCount: segments.filter((s) => s !== null).length, seconds });
+  ROUTES.set(method, list);
+}
+function operationDefaultTimeout(method, pathname) {
+  const candidates = ROUTES.get(method.toUpperCase());
+  if (!candidates)
+    return;
+  const segments = pathname.split("/").filter(Boolean).map((s) => s.toLowerCase());
+  let best;
+  for (const route of candidates) {
+    if (route.segments.length !== segments.length)
+      continue;
+    if (!route.segments.every((s, i) => s === null || s === segments[i]))
+      continue;
+    if (!best || route.staticCount > best.staticCount)
+      best = route;
+  }
+  return best?.seconds;
+}
+function parseSeconds(value) {
+  if (value == null || value.trim() === "")
+    return;
+  const seconds = Number(value.trim());
+  return Number.isFinite(seconds) && seconds > 0 ? seconds : undefined;
+}
+function planRequestTimeout(args) {
+  const { method, url, headers, perCall, clientDefault, timeoutMs } = args;
+  const operationDefault = operationDefaultTimeout(method, url.pathname);
+  let send;
+  let serverSeconds;
+  if (perCall !== undefined) {
+    send = validateRequestTimeout(perCall);
+    serverSeconds = send;
+  } else {
+    const manualHeader = Object.entries(headers).find(([k]) => k.toLowerCase() === REQUEST_TIMEOUT_HEADER.toLowerCase());
+    const manual = manualHeader ? parseSeconds(manualHeader[1]) : parseSeconds(url.searchParams.get(REQUEST_TIMEOUT_QUERY));
+    if (manualHeader || url.searchParams.has(REQUEST_TIMEOUT_QUERY)) {
+      serverSeconds = manual;
+    } else if (clientDefault !== undefined && operationDefault !== undefined) {
+      send = clientDefault;
+      serverSeconds = clientDefault;
+    }
+  }
+  serverSeconds ??= operationDefault;
+  const deadlineMs = serverSeconds === undefined ? timeoutMs : Math.max(timeoutMs, Math.ceil(serverSeconds * 1000) + SERVER_ANSWER_MARGIN_MS);
+  return { send, deadlineMs };
+}
+function setTimeoutHeader(headers, seconds) {
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === REQUEST_TIMEOUT_HEADER.toLowerCase())
+      delete headers[key];
+  }
+  headers[REQUEST_TIMEOUT_HEADER] = String(seconds);
+}
+
+// src/mutator.ts
+async function authenticatedFetch(ctx, url, options, consume) {
+  const fullUrl = new URL(url, ctx.apiBaseUrl);
+  const { requestTimeout, ...fetchOptions } = options;
+  const requestOptions = fetchOptions;
+  delete requestOptions[requestContext];
+  const headerObj = {};
+  if (options.headers) {
+    if (options.headers instanceof Headers) {
+      options.headers.forEach((value, key) => {
+        headerObj[key] = value;
+      });
+    } else if (Array.isArray(options.headers)) {
+      for (const [key, value] of options.headers)
+        headerObj[key] = value;
+    } else {
+      Object.assign(headerObj, options.headers);
+    }
+  }
+  const method = (options.method ?? "GET").toUpperCase();
+  const plan = planRequestTimeout({
+    method,
+    url: fullUrl,
+    headers: headerObj,
+    perCall: requestTimeout,
+    clientDefault: ctx.requestTimeout,
+    timeoutMs: ctx.timeoutMs
+  });
+  if (plan.send !== undefined)
+    setTimeoutHeader(headerObj, plan.send);
+  return withDeadline(plan.deadlineMs, options.signal, async (signal) => {
+    const isIdempotent = method === "GET" || method === "HEAD" || method === "OPTIONS" || method === "PUT" || method === "DELETE";
+    const doFetch = async (forceRefresh) => {
+      const token = await ctx.tokenProvider.getToken({
+        ...forceRefresh ? { forceRefresh: true } : {},
+        signal
+      });
+      return ctx.fetchImpl(fullUrl.toString(), {
+        ...requestOptions,
+        method,
+        headers: {
+          ...headerObj,
+          Authorization: "Bearer " + token,
+          Accept: "application/json"
+        },
+        signal,
+        redirect: "error"
+      });
+    };
+    const outcome = await withRetry(async () => {
+      let response = await doFetch(false);
+      if (response.status === 401 && isIdempotent)
+        response = await doFetch(true);
+      return { response, result: response };
+    }, { policy: ctx.retryPolicy, isIdempotent, signal });
+    return consume(outcome.response, signal);
+  });
+}
+async function customFetch(url, options) {
+  const ctx = contextFromOptions(options);
+  return authenticatedFetch(ctx, url, options, async (response) => {
+    const details = errorDetails(response);
+    if (!response.ok) {
+      const text = await response.text();
+      try {
+        const env = JSON.parse(text);
+        if (env.error != null)
+          throw new ApiError(env.error, env.meta, response.status, details);
+        throw new ApiError({ code: codeForHttpStatus(response.status), message: "HTTP " + response.status }, env.meta ?? null, response.status, details);
+      } catch (error) {
+        if (error instanceof ApiError)
+          throw error;
+        throw new ApiError({ code: codeForHttpStatus(response.status), message: "HTTP " + response.status }, null, response.status, details);
+      }
+    }
+    const envelope = await response.json();
+    if (envelope.error != null)
+      throw new ApiError(envelope.error, envelope.meta, response.status, details);
+    return attachResponseMeta(envelope.data, envelope.meta);
+  });
+}
+function errorDetails(response) {
+  const applied = Number(response.headers.get(REQUEST_TIMEOUT_APPLIED_HEADER) ?? Number.NaN);
+  return {
+    outcome: parseRequestOutcome(response.headers.get(REQUEST_OUTCOME_HEADER)),
+    appliedTimeout: Number.isFinite(applied) ? applied : undefined
+  };
+}
+function attachResponseMeta(data, meta) {
+  if (data !== null && (typeof data === "object" || typeof data === "function")) {
+    Object.defineProperty(data, responseMeta, { value: meta ?? null, enumerable: false, configurable: true });
+  }
+  return data;
+}
+function pagingFromResult(items) {
+  if (items !== null && (typeof items === "object" || typeof items === "function")) {
+    return items[responseMeta] ?? null;
+  }
+  return null;
+}
+
+// src/generated/mt4-v2-authentication.ts
+var exports_mt4_v2_authentication = {};
+__export(exports_mt4_v2_authentication, {
+  postUserPasswordSetLogin: () => postUserPasswordSetLogin,
+  postUserPasswordCheckLogin: () => postUserPasswordCheckLogin,
+  getPostUserPasswordSetLoginUrl: () => getPostUserPasswordSetLoginUrl,
+  getPostUserPasswordCheckLoginUrl: () => getPostUserPasswordCheckLoginUrl
+});
+var getPostUserPasswordCheckLoginUrl = (tradePlatform, login) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UserPasswordCheck/${encodeURIComponent(String(login))}`;
+};
+var postUserPasswordCheckLogin = async (tradePlatform, login, postUserPasswordCheckLoginBody, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostUserPasswordCheckLoginUrl(tradePlatform, login), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(postUserPasswordCheckLoginBody)
+  });
+};
+var getPostUserPasswordSetLoginUrl = (tradePlatform, login, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UserPasswordSet/${encodeURIComponent(String(login))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UserPasswordSet/${encodeURIComponent(String(login))}`;
+};
+var postUserPasswordSetLogin = async (tradePlatform, login, postUserPasswordSetLoginBody, params, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostUserPasswordSetLoginUrl(tradePlatform, login, params), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(postUserPasswordSetLoginBody)
+  });
+};
+
+// src/generated/mt4-v2-backup-destructive.ts
+var exports_mt4_v2_backup_destructive = {};
+__export(exports_mt4_v2_backup_destructive, {
+  postBackupRestoreUsers: () => postBackupRestoreUsers,
+  postBackupRestoreOrders: () => postBackupRestoreOrders,
+  getPostBackupRestoreUsersUrl: () => getPostBackupRestoreUsersUrl,
+  getPostBackupRestoreOrdersUrl: () => getPostBackupRestoreOrdersUrl
+});
+var getPostBackupRestoreUsersUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/BackupRestoreUsers?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/BackupRestoreUsers`;
+};
+var postBackupRestoreUsers = async (tradePlatform, mT4UserRestoreInput, params, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostBackupRestoreUsersUrl(tradePlatform, params), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4UserRestoreInput)
+  });
+};
+var getPostBackupRestoreOrdersUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/BackupRestoreOrders?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/BackupRestoreOrders`;
+};
+var postBackupRestoreOrders = async (tradePlatform, mT4TradeRestoreInput, params, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostBackupRestoreOrdersUrl(tradePlatform, params), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4TradeRestoreInput)
+  });
+};
+
+// src/generated/mt4-v2-backup.ts
+var exports_mt4_v2_backup = {};
+__export(exports_mt4_v2_backup, {
+  getGetBackupRequestUsersFileUrl: () => getGetBackupRequestUsersFileUrl,
+  getGetBackupRequestOrdersFileUrl: () => getGetBackupRequestOrdersFileUrl,
+  getGetBackupInfoUsersModeUrl: () => getGetBackupInfoUsersModeUrl,
+  getGetBackupInfoOrdersModeUrl: () => getGetBackupInfoOrdersModeUrl,
+  getBackupRequestUsersFile: () => getBackupRequestUsersFile,
+  getBackupRequestOrdersFile: () => getBackupRequestOrdersFile,
+  getBackupInfoUsersMode: () => getBackupInfoUsersMode,
+  getBackupInfoOrdersMode: () => getBackupInfoOrdersMode
+});
+var getGetBackupInfoUsersModeUrl = (tradePlatform, mode) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/BackupInfoUsers/${encodeURIComponent(String(mode))}`;
+};
+var getBackupInfoUsersMode = async (tradePlatform, mode, options) => {
+  return customFetch(getGetBackupInfoUsersModeUrl(tradePlatform, mode), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetBackupInfoOrdersModeUrl = (tradePlatform, mode) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/BackupInfoOrders/${encodeURIComponent(String(mode))}`;
+};
+var getBackupInfoOrdersMode = async (tradePlatform, mode, options) => {
+  return customFetch(getGetBackupInfoOrdersModeUrl(tradePlatform, mode), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetBackupRequestUsersFileUrl = (tradePlatform, file, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/BackupRequestUsers/${encodeURIComponent(String(file))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/BackupRequestUsers/${encodeURIComponent(String(file))}`;
+};
+var getBackupRequestUsersFile = async (tradePlatform, file, params, options) => {
+  return customFetch(getGetBackupRequestUsersFileUrl(tradePlatform, file, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetBackupRequestOrdersFileUrl = (tradePlatform, file, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/BackupRequestOrders/${encodeURIComponent(String(file))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/BackupRequestOrders/${encodeURIComponent(String(file))}`;
+};
+var getBackupRequestOrdersFile = async (tradePlatform, file, params, options) => {
+  return customFetch(getGetBackupRequestOrdersFileUrl(tradePlatform, file, params), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-common.ts
+var exports_mt4_v2_common = {};
+__export(exports_mt4_v2_common, {
+  getServerTimeMT4: () => getServerTimeMT4,
+  getManagerCommon: () => getManagerCommon,
+  getJournalRequest: () => getJournalRequest,
+  getGetServerTimeMT4Url: () => getGetServerTimeMT4Url,
+  getGetManagerCommonUrl: () => getGetManagerCommonUrl,
+  getGetJournalRequestUrl: () => getGetJournalRequestUrl
+});
+var getGetServerTimeMT4Url = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ServerTime`;
+};
+var getServerTimeMT4 = async (tradePlatform, options) => {
+  return customFetch(getGetServerTimeMT4Url(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetManagerCommonUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ManagerCommon`;
+};
+var getManagerCommon = async (tradePlatform, options) => {
+  return customFetch(getGetManagerCommonUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetJournalRequestUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/JournalRequest?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/JournalRequest`;
+};
+var getJournalRequest = async (tradePlatform, params, options) => {
+  return customFetch(getGetJournalRequestUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-config.ts
+var exports_mt4_v2_config = {};
+__export(exports_mt4_v2_config, {
+  postCfgUpdateTime: () => postCfgUpdateTime,
+  postCfgUpdateSync: () => postCfgUpdateSync,
+  postCfgUpdateSymbolGroupPos: () => postCfgUpdateSymbolGroupPos,
+  postCfgUpdateManager: () => postCfgUpdateManager,
+  postCfgUpdateLiveUpdate: () => postCfgUpdateLiveUpdate,
+  postCfgUpdateHolidayPos: () => postCfgUpdateHolidayPos,
+  postCfgUpdateGatewayRule: () => postCfgUpdateGatewayRule,
+  postCfgUpdateGatewayMarkup: () => postCfgUpdateGatewayMarkup,
+  postCfgUpdateGatewayAccount: () => postCfgUpdateGatewayAccount,
+  postCfgUpdateFeeder: () => postCfgUpdateFeeder,
+  postCfgUpdateDataServerPos: () => postCfgUpdateDataServerPos,
+  postCfgUpdateCommon: () => postCfgUpdateCommon,
+  postCfgUpdateBackup: () => postCfgUpdateBackup,
+  postCfgUpdateAccessPos: () => postCfgUpdateAccessPos,
+  postCfgShiftSyncPos: () => postCfgShiftSyncPos,
+  postCfgShiftSymbolPos: () => postCfgShiftSymbolPos,
+  postCfgShiftPluginPos: () => postCfgShiftPluginPos,
+  postCfgShiftManagerPos: () => postCfgShiftManagerPos,
+  postCfgShiftLiveUpdatePos: () => postCfgShiftLiveUpdatePos,
+  postCfgShiftHolidayPos: () => postCfgShiftHolidayPos,
+  postCfgShiftGroupPos: () => postCfgShiftGroupPos,
+  postCfgShiftGatewayRulePos: () => postCfgShiftGatewayRulePos,
+  postCfgShiftGatewayMarkupPos: () => postCfgShiftGatewayMarkupPos,
+  postCfgShiftGatewayAccountPos: () => postCfgShiftGatewayAccountPos,
+  postCfgShiftFeederPos: () => postCfgShiftFeederPos,
+  postCfgShiftDataServerPos: () => postCfgShiftDataServerPos,
+  postCfgShiftAccessPos: () => postCfgShiftAccessPos,
+  postCfgDeleteSyncPos: () => postCfgDeleteSyncPos,
+  postCfgDeleteSymbolPos: () => postCfgDeleteSymbolPos,
+  postCfgDeleteManagerPos: () => postCfgDeleteManagerPos,
+  postCfgDeleteLiveUpdatePos: () => postCfgDeleteLiveUpdatePos,
+  postCfgDeleteHolidayPos: () => postCfgDeleteHolidayPos,
+  postCfgDeleteGatewayRulePos: () => postCfgDeleteGatewayRulePos,
+  postCfgDeleteGatewayMarkupPos: () => postCfgDeleteGatewayMarkupPos,
+  postCfgDeleteGatewayAccountPos: () => postCfgDeleteGatewayAccountPos,
+  postCfgDeleteFeederPos: () => postCfgDeleteFeederPos,
+  postCfgDeleteDataServerPos: () => postCfgDeleteDataServerPos,
+  postCfgDeleteAccessPos: () => postCfgDeleteAccessPos,
+  getPostCfgUpdateTimeUrl: () => getPostCfgUpdateTimeUrl,
+  getPostCfgUpdateSyncUrl: () => getPostCfgUpdateSyncUrl,
+  getPostCfgUpdateSymbolGroupPosUrl: () => getPostCfgUpdateSymbolGroupPosUrl,
+  getPostCfgUpdateManagerUrl: () => getPostCfgUpdateManagerUrl,
+  getPostCfgUpdateLiveUpdateUrl: () => getPostCfgUpdateLiveUpdateUrl,
+  getPostCfgUpdateHolidayPosUrl: () => getPostCfgUpdateHolidayPosUrl,
+  getPostCfgUpdateGatewayRuleUrl: () => getPostCfgUpdateGatewayRuleUrl,
+  getPostCfgUpdateGatewayMarkupUrl: () => getPostCfgUpdateGatewayMarkupUrl,
+  getPostCfgUpdateGatewayAccountUrl: () => getPostCfgUpdateGatewayAccountUrl,
+  getPostCfgUpdateFeederUrl: () => getPostCfgUpdateFeederUrl,
+  getPostCfgUpdateDataServerPosUrl: () => getPostCfgUpdateDataServerPosUrl,
+  getPostCfgUpdateCommonUrl: () => getPostCfgUpdateCommonUrl,
+  getPostCfgUpdateBackupUrl: () => getPostCfgUpdateBackupUrl,
+  getPostCfgUpdateAccessPosUrl: () => getPostCfgUpdateAccessPosUrl,
+  getPostCfgShiftSyncPosUrl: () => getPostCfgShiftSyncPosUrl,
+  getPostCfgShiftSymbolPosUrl: () => getPostCfgShiftSymbolPosUrl,
+  getPostCfgShiftPluginPosUrl: () => getPostCfgShiftPluginPosUrl,
+  getPostCfgShiftManagerPosUrl: () => getPostCfgShiftManagerPosUrl,
+  getPostCfgShiftLiveUpdatePosUrl: () => getPostCfgShiftLiveUpdatePosUrl,
+  getPostCfgShiftHolidayPosUrl: () => getPostCfgShiftHolidayPosUrl,
+  getPostCfgShiftGroupPosUrl: () => getPostCfgShiftGroupPosUrl,
+  getPostCfgShiftGatewayRulePosUrl: () => getPostCfgShiftGatewayRulePosUrl,
+  getPostCfgShiftGatewayMarkupPosUrl: () => getPostCfgShiftGatewayMarkupPosUrl,
+  getPostCfgShiftGatewayAccountPosUrl: () => getPostCfgShiftGatewayAccountPosUrl,
+  getPostCfgShiftFeederPosUrl: () => getPostCfgShiftFeederPosUrl,
+  getPostCfgShiftDataServerPosUrl: () => getPostCfgShiftDataServerPosUrl,
+  getPostCfgShiftAccessPosUrl: () => getPostCfgShiftAccessPosUrl,
+  getPostCfgDeleteSyncPosUrl: () => getPostCfgDeleteSyncPosUrl,
+  getPostCfgDeleteSymbolPosUrl: () => getPostCfgDeleteSymbolPosUrl,
+  getPostCfgDeleteManagerPosUrl: () => getPostCfgDeleteManagerPosUrl,
+  getPostCfgDeleteLiveUpdatePosUrl: () => getPostCfgDeleteLiveUpdatePosUrl,
+  getPostCfgDeleteHolidayPosUrl: () => getPostCfgDeleteHolidayPosUrl,
+  getPostCfgDeleteGatewayRulePosUrl: () => getPostCfgDeleteGatewayRulePosUrl,
+  getPostCfgDeleteGatewayMarkupPosUrl: () => getPostCfgDeleteGatewayMarkupPosUrl,
+  getPostCfgDeleteGatewayAccountPosUrl: () => getPostCfgDeleteGatewayAccountPosUrl,
+  getPostCfgDeleteFeederPosUrl: () => getPostCfgDeleteFeederPosUrl,
+  getPostCfgDeleteDataServerPosUrl: () => getPostCfgDeleteDataServerPosUrl,
+  getPostCfgDeleteAccessPosUrl: () => getPostCfgDeleteAccessPosUrl,
+  getGetCfgRequestTimeUrl: () => getGetCfgRequestTimeUrl,
+  getGetCfgRequestSyncUrl: () => getGetCfgRequestSyncUrl,
+  getGetCfgRequestManagerUrl: () => getGetCfgRequestManagerUrl,
+  getGetCfgRequestLiveUpdateUrl: () => getGetCfgRequestLiveUpdateUrl,
+  getGetCfgRequestHolidayUrl: () => getGetCfgRequestHolidayUrl,
+  getGetCfgRequestGatewayRuleUrl: () => getGetCfgRequestGatewayRuleUrl,
+  getGetCfgRequestGatewayMarkupUrl: () => getGetCfgRequestGatewayMarkupUrl,
+  getGetCfgRequestGatewayAccountUrl: () => getGetCfgRequestGatewayAccountUrl,
+  getGetCfgRequestFeederUrl: () => getGetCfgRequestFeederUrl,
+  getGetCfgRequestDataServerUrl: () => getGetCfgRequestDataServerUrl,
+  getGetCfgRequestCommonUrl: () => getGetCfgRequestCommonUrl,
+  getGetCfgRequestBackupUrl: () => getGetCfgRequestBackupUrl,
+  getGetCfgRequestAccessUrl: () => getGetCfgRequestAccessUrl,
+  getCfgRequestTime: () => getCfgRequestTime,
+  getCfgRequestSync: () => getCfgRequestSync,
+  getCfgRequestManager: () => getCfgRequestManager,
+  getCfgRequestLiveUpdate: () => getCfgRequestLiveUpdate,
+  getCfgRequestHoliday: () => getCfgRequestHoliday,
+  getCfgRequestGatewayRule: () => getCfgRequestGatewayRule,
+  getCfgRequestGatewayMarkup: () => getCfgRequestGatewayMarkup,
+  getCfgRequestGatewayAccount: () => getCfgRequestGatewayAccount,
+  getCfgRequestFeeder: () => getCfgRequestFeeder,
+  getCfgRequestDataServer: () => getCfgRequestDataServer,
+  getCfgRequestCommon: () => getCfgRequestCommon,
+  getCfgRequestBackup: () => getCfgRequestBackup,
+  getCfgRequestAccess: () => getCfgRequestAccess
+});
+var getGetCfgRequestCommonUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestCommon`;
+};
+var getCfgRequestCommon = async (tradePlatform, options) => {
+  return customFetch(getGetCfgRequestCommonUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostCfgUpdateCommonUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateCommon`;
+};
+var postCfgUpdateCommon = async (tradePlatform, mT4CommonUpdate, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateCommonUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4CommonUpdate)
+  });
+};
+var getGetCfgRequestHolidayUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestHoliday?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestHoliday`;
+};
+var getCfgRequestHoliday = async (tradePlatform, params, options) => {
+  return customFetch(getGetCfgRequestHolidayUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestManagerUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestManager?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestManager`;
+};
+var getCfgRequestManager = async (tradePlatform, params, options) => {
+  return customFetch(getGetCfgRequestManagerUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestTimeUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestTime`;
+};
+var getCfgRequestTime = async (tradePlatform, options) => {
+  return customFetch(getGetCfgRequestTimeUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostCfgUpdateTimeUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateTime`;
+};
+var postCfgUpdateTime = async (tradePlatform, mT4ServerTime, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateTimeUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4ServerTime)
+  });
+};
+var getGetCfgRequestAccessUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestAccess?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestAccess`;
+};
+var getCfgRequestAccess = async (tradePlatform, params, options) => {
+  return customFetch(getGetCfgRequestAccessUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestBackupUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestBackup`;
+};
+var getCfgRequestBackup = async (tradePlatform, options) => {
+  return customFetch(getGetCfgRequestBackupUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostCfgUpdateBackupUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateBackup`;
+};
+var postCfgUpdateBackup = async (tradePlatform, mT4Backup, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateBackupUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4Backup)
+  });
+};
+var getPostCfgUpdateSyncUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateSync`;
+};
+var postCfgUpdateSync = async (tradePlatform, mT4Sync, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateSyncUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4Sync)
+  });
+};
+var getPostCfgUpdateFeederUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateFeeder`;
+};
+var postCfgUpdateFeeder = async (tradePlatform, mT4Feeder, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateFeederUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4Feeder)
+  });
+};
+var getPostCfgUpdateGatewayAccountUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateGatewayAccount`;
+};
+var postCfgUpdateGatewayAccount = async (tradePlatform, mT4GatewayAccount, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateGatewayAccountUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4GatewayAccount)
+  });
+};
+var getPostCfgUpdateGatewayMarkupUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateGatewayMarkup`;
+};
+var postCfgUpdateGatewayMarkup = async (tradePlatform, mT4GatewayMarkup, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateGatewayMarkupUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4GatewayMarkup)
+  });
+};
+var getPostCfgUpdateGatewayRuleUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateGatewayRule`;
+};
+var postCfgUpdateGatewayRule = async (tradePlatform, mT4GatewayRule, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateGatewayRuleUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4GatewayRule)
+  });
+};
+var getPostCfgUpdateLiveUpdateUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateLiveUpdate`;
+};
+var postCfgUpdateLiveUpdate = async (tradePlatform, mT4LiveUpdate, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateLiveUpdateUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4LiveUpdate)
+  });
+};
+var getPostCfgUpdateManagerUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateManager`;
+};
+var postCfgUpdateManager = async (tradePlatform, mT4ManagerRights, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateManagerUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4ManagerRights)
+  });
+};
+var getPostCfgUpdateAccessPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateAccess/${encodeURIComponent(String(pos))}`;
+};
+var postCfgUpdateAccessPos = async (tradePlatform, pos, mT4Access, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateAccessPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4Access)
+  });
+};
+var getPostCfgUpdateDataServerPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateDataServer/${encodeURIComponent(String(pos))}`;
+};
+var postCfgUpdateDataServerPos = async (tradePlatform, pos, mT4DataServer, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateDataServerPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4DataServer)
+  });
+};
+var getPostCfgUpdateHolidayPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateHoliday/${encodeURIComponent(String(pos))}`;
+};
+var postCfgUpdateHolidayPos = async (tradePlatform, pos, mT4Holiday, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateHolidayPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4Holiday)
+  });
+};
+var getPostCfgUpdateSymbolGroupPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateSymbolGroup/${encodeURIComponent(String(pos))}`;
+};
+var postCfgUpdateSymbolGroupPos = async (tradePlatform, pos, mT4SymbolGroup, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateSymbolGroupPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4SymbolGroup)
+  });
+};
+var getGetCfgRequestGatewayAccountUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestGatewayAccount?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestGatewayAccount`;
+};
+var getCfgRequestGatewayAccount = async (tradePlatform, params, options) => {
+  return customFetch(getGetCfgRequestGatewayAccountUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestGatewayMarkupUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestGatewayMarkup?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestGatewayMarkup`;
+};
+var getCfgRequestGatewayMarkup = async (tradePlatform, params, options) => {
+  return customFetch(getGetCfgRequestGatewayMarkupUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestGatewayRuleUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestGatewayRule?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestGatewayRule`;
+};
+var getCfgRequestGatewayRule = async (tradePlatform, params, options) => {
+  return customFetch(getGetCfgRequestGatewayRuleUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestDataServerUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestDataServer?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestDataServer`;
+};
+var getCfgRequestDataServer = async (tradePlatform, params, options) => {
+  return customFetch(getGetCfgRequestDataServerUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestFeederUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestFeeder?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestFeeder`;
+};
+var getCfgRequestFeeder = async (tradePlatform, params, options) => {
+  return customFetch(getGetCfgRequestFeederUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestLiveUpdateUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestLiveUpdate?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestLiveUpdate`;
+};
+var getCfgRequestLiveUpdate = async (tradePlatform, params, options) => {
+  return customFetch(getGetCfgRequestLiveUpdateUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestSyncUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestSync?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestSync`;
+};
+var getCfgRequestSync = async (tradePlatform, params, options) => {
+  return customFetch(getGetCfgRequestSyncUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostCfgDeleteAccessPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteAccess/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteAccessPos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteAccessPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgDeleteDataServerPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteDataServer/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteDataServerPos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteDataServerPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgDeleteFeederPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteFeeder/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteFeederPos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteFeederPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgDeleteGatewayAccountPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteGatewayAccount/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteGatewayAccountPos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteGatewayAccountPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgDeleteGatewayMarkupPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteGatewayMarkup/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteGatewayMarkupPos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteGatewayMarkupPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgDeleteGatewayRulePosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteGatewayRule/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteGatewayRulePos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteGatewayRulePosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgDeleteHolidayPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteHoliday/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteHolidayPos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteHolidayPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgDeleteLiveUpdatePosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteLiveUpdate/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteLiveUpdatePos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteLiveUpdatePosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgDeleteManagerPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteManager/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteManagerPos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteManagerPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgDeleteSymbolPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteSymbol/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteSymbolPos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteSymbolPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgDeleteSyncPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgDeleteSync/${encodeURIComponent(String(pos))}`;
+};
+var postCfgDeleteSyncPos = async (tradePlatform, pos, options) => {
+  return customFetch(getPostCfgDeleteSyncPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftAccessPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftAccess/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftAccess/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftAccessPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftAccessPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftDataServerPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftDataServer/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftDataServer/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftDataServerPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftDataServerPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftFeederPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftFeeder/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftFeeder/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftFeederPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftFeederPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftGatewayAccountPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftGatewayAccount/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftGatewayAccount/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftGatewayAccountPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftGatewayAccountPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftGatewayMarkupPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftGatewayMarkup/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftGatewayMarkup/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftGatewayMarkupPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftGatewayMarkupPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftGatewayRulePosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftGatewayRule/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftGatewayRule/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftGatewayRulePos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftGatewayRulePosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftGroupPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftGroup/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftGroup/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftGroupPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftGroupPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftHolidayPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftHoliday/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftHoliday/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftHolidayPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftHolidayPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftLiveUpdatePosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftLiveUpdate/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftLiveUpdate/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftLiveUpdatePos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftLiveUpdatePosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftManagerPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftManager/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftManager/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftManagerPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftManagerPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftPluginPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftPlugin/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftPlugin/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftPluginPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftPluginPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftSymbolPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftSymbol/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftSymbol/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftSymbolPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftSymbolPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostCfgShiftSyncPosUrl = (tradePlatform, pos, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftSync/${encodeURIComponent(String(pos))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgShiftSync/${encodeURIComponent(String(pos))}`;
+};
+var postCfgShiftSyncPos = async (tradePlatform, pos, params, options) => {
+  return customFetch(getPostCfgShiftSyncPosUrl(tradePlatform, pos, params), {
+    ...options,
+    method: "POST"
+  });
+};
+
+// src/generated/mt4-v2-groups.ts
+var exports_mt4_v2_groups = {};
+__export(exports_mt4_v2_groups, {
+  postGroupRecordUpdateGroup: () => postGroupRecordUpdateGroup,
+  patchGroupRecordGroupMT4: () => patchGroupRecordGroupMT4,
+  getPostGroupRecordUpdateGroupUrl: () => getPostGroupRecordUpdateGroupUrl,
+  getPatchGroupRecordGroupMT4Url: () => getPatchGroupRecordGroupMT4Url,
+  getGroupsRequest: () => getGroupsRequest,
+  getGroupsGet: () => getGroupsGet,
+  getGroupSecMarginsGetGroup: () => getGroupSecMarginsGetGroup,
+  getGroupSecGroupsGetGroup: () => getGroupSecGroupsGetGroup,
+  getGroupRecordGetGroup: () => getGroupRecordGetGroup,
+  getGetGroupsRequestUrl: () => getGetGroupsRequestUrl,
+  getGetGroupsGetUrl: () => getGetGroupsGetUrl,
+  getGetGroupSecMarginsGetGroupUrl: () => getGetGroupSecMarginsGetGroupUrl,
+  getGetGroupSecGroupsGetGroupUrl: () => getGetGroupSecGroupsGetGroupUrl,
+  getGetGroupRecordGetGroupUrl: () => getGetGroupRecordGetGroupUrl,
+  getGetEnsureGroupNameExistGroupUrl: () => getGetEnsureGroupNameExistGroupUrl,
+  getEnsureGroupNameExistGroup: () => getEnsureGroupNameExistGroup
+});
+var getGetGroupsGetUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/GroupsGet`;
+};
+var getGroupsGet = async (tradePlatform, options) => {
+  return customFetch(getGetGroupsGetUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetGroupRecordGetGroupUrl = (tradePlatform, group) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/GroupRecordGet/${encodeURIComponent(String(group))}`;
+};
+var getGroupRecordGetGroup = async (tradePlatform, group, options) => {
+  return customFetch(getGetGroupRecordGetGroupUrl(tradePlatform, group), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetGroupsRequestUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/GroupsRequest?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/GroupsRequest`;
+};
+var getGroupsRequest = async (tradePlatform, params, options) => {
+  return customFetch(getGetGroupsRequestUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetGroupSecGroupsGetGroupUrl = (tradePlatform, group) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/GroupSecGroupsGet/${encodeURIComponent(String(group))}`;
+};
+var getGroupSecGroupsGetGroup = async (tradePlatform, group, options) => {
+  return customFetch(getGetGroupSecGroupsGetGroupUrl(tradePlatform, group), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetGroupSecMarginsGetGroupUrl = (tradePlatform, group) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/GroupSecMarginsGet/${encodeURIComponent(String(group))}`;
+};
+var getGroupSecMarginsGetGroup = async (tradePlatform, group, options) => {
+  return customFetch(getGetGroupSecMarginsGetGroupUrl(tradePlatform, group), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostGroupRecordUpdateGroupUrl = (tradePlatform, group) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/GroupRecordUpdate/${encodeURIComponent(String(group))}`;
+};
+var postGroupRecordUpdateGroup = async (tradePlatform, group, mT4GroupUpdate, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostGroupRecordUpdateGroupUrl(tradePlatform, group), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4GroupUpdate)
+  });
+};
+var getPatchGroupRecordGroupMT4Url = (tradePlatform, group) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/GroupRecord/${encodeURIComponent(String(group))}`;
+};
+var patchGroupRecordGroupMT4 = async (tradePlatform, group, patchGroupRecordGroupMT4Body, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPatchGroupRecordGroupMT4Url(tradePlatform, group), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(patchGroupRecordGroupMT4Body)
+  });
+};
+var getGetEnsureGroupNameExistGroupUrl = (tradePlatform, group) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/EnsureGroupNameExist/${encodeURIComponent(String(group))}`;
+};
+var getEnsureGroupNameExistGroup = async (tradePlatform, group, options) => {
+  return customFetch(getGetEnsureGroupNameExistGroupUrl(tradePlatform, group), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-history.ts
+var exports_mt4_v2_history = {};
+__export(exports_mt4_v2_history, {
+  getTradesUserHistoryLogin: () => getTradesUserHistoryLogin,
+  getGetTradesUserHistoryLoginUrl: () => getGetTradesUserHistoryLoginUrl
+});
+var getGetTradesUserHistoryLoginUrl = (tradePlatform, login, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesUserHistory/${encodeURIComponent(String(login))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesUserHistory/${encodeURIComponent(String(login))}`;
+};
+var getTradesUserHistoryLogin = async (tradePlatform, login, params, options) => {
+  return customFetch(getGetTradesUserHistoryLoginUrl(tradePlatform, login, params), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-mail.ts
+var exports_mt4_v2_mail = {};
+__export(exports_mt4_v2_mail, {
+  getMailLast: () => getMailLast,
+  getGetMailLastUrl: () => getGetMailLastUrl
+});
+var getGetMailLastUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/MailLast`;
+};
+var getMailLast = async (tradePlatform, options) => {
+  return customFetch(getGetMailLastUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-margins.ts
+var exports_mt4_v2_margins = {};
+__export(exports_mt4_v2_margins, {
+  getMarginsGet: () => getMarginsGet,
+  getMarginLevelRequestLogin: () => getMarginLevelRequestLogin,
+  getMarginLevelGetLogin: () => getMarginLevelGetLogin,
+  getGetMarginsGetUrl: () => getGetMarginsGetUrl,
+  getGetMarginLevelRequestLoginUrl: () => getGetMarginLevelRequestLoginUrl,
+  getGetMarginLevelGetLoginUrl: () => getGetMarginLevelGetLoginUrl
+});
+var getGetMarginsGetUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/MarginsGet`;
+};
+var getMarginsGet = async (tradePlatform, options) => {
+  return customFetch(getGetMarginsGetUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetMarginLevelGetLoginUrl = (tradePlatform, login) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/MarginLevelGet/${encodeURIComponent(String(login))}`;
+};
+var getMarginLevelGetLogin = async (tradePlatform, login, options) => {
+  return customFetch(getGetMarginLevelGetLoginUrl(tradePlatform, login), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetMarginLevelRequestLoginUrl = (tradePlatform, login) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/MarginLevelRequest/${encodeURIComponent(String(login))}`;
+};
+var getMarginLevelRequestLogin = async (tradePlatform, login, options) => {
+  return customFetch(getGetMarginLevelRequestLoginUrl(tradePlatform, login), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-news.ts
+var exports_mt4_v2_news = {};
+__export(exports_mt4_v2_news, {
+  postNewsBodyRequestKey: () => postNewsBodyRequestKey,
+  getPostNewsBodyRequestKeyUrl: () => getPostNewsBodyRequestKeyUrl,
+  getNewsTotal: () => getNewsTotal,
+  getNewsTopicGetPos: () => getNewsTopicGetPos,
+  getNewsGet: () => getNewsGet,
+  getNewsBodyGetKey: () => getNewsBodyGetKey,
+  getGetNewsTotalUrl: () => getGetNewsTotalUrl,
+  getGetNewsTopicGetPosUrl: () => getGetNewsTopicGetPosUrl,
+  getGetNewsGetUrl: () => getGetNewsGetUrl,
+  getGetNewsBodyGetKeyUrl: () => getGetNewsBodyGetKeyUrl
+});
+var getGetNewsTotalUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/NewsTotal`;
+};
+var getNewsTotal = async (tradePlatform, options) => {
+  return customFetch(getGetNewsTotalUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetNewsBodyGetKeyUrl = (tradePlatform, key) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/NewsBodyGet/${encodeURIComponent(String(key))}`;
+};
+var getNewsBodyGetKey = async (tradePlatform, key, options) => {
+  return customFetch(getGetNewsBodyGetKeyUrl(tradePlatform, key), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetNewsGetUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/NewsGet`;
+};
+var getNewsGet = async (tradePlatform, options) => {
+  return customFetch(getGetNewsGetUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetNewsTopicGetPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/NewsTopicGet/${encodeURIComponent(String(pos))}`;
+};
+var getNewsTopicGetPos = async (tradePlatform, pos, options) => {
+  return customFetch(getGetNewsTopicGetPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostNewsBodyRequestKeyUrl = (tradePlatform, key) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/NewsBodyRequest/${encodeURIComponent(String(key))}`;
+};
+var postNewsBodyRequestKey = async (tradePlatform, key, options) => {
+  return customFetch(getPostNewsBodyRequestKeyUrl(tradePlatform, key), {
+    ...options,
+    method: "POST"
+  });
+};
+
+// src/generated/mt4-v2-online.ts
+var exports_mt4_v2_online = {};
+__export(exports_mt4_v2_online, {
+  getOnlineRequest: () => getOnlineRequest,
+  getOnlineGet: () => getOnlineGet,
+  getGetOnlineRequestUrl: () => getGetOnlineRequestUrl,
+  getGetOnlineGetUrl: () => getGetOnlineGetUrl
+});
+var getGetOnlineGetUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/OnlineGet?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/OnlineGet`;
+};
+var getOnlineGet = async (tradePlatform, params, options) => {
+  return customFetch(getGetOnlineGetUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetOnlineRequestUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/OnlineRequest?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/OnlineRequest`;
+};
+var getOnlineRequest = async (tradePlatform, params, options) => {
+  return customFetch(getGetOnlineRequestUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-plugins.ts
+var exports_mt4_v2_plugins = {};
+__export(exports_mt4_v2_plugins, {
+  postExternalCommandJSON: () => postExternalCommandJSON,
+  getPostExternalCommandJSONUrl: () => getPostExternalCommandJSONUrl
+});
+var getPostExternalCommandJSONUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ExternalCommandJSON`;
+};
+var postExternalCommandJSON = async (tradePlatform, postExternalCommandJSONBody, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostExternalCommandJSONUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(postExternalCommandJSONBody)
+  });
+};
+
+// src/generated/mt4-v2-prices.ts
+var exports_mt4_v2_prices = {};
+__export(exports_mt4_v2_prices, {
+  postHistoryCorrectSymbol: () => postHistoryCorrectSymbol,
+  postChartUpdateSymbol: () => postChartUpdateSymbol,
+  postChartDeleteSymbol: () => postChartDeleteSymbol,
+  postChartAddSymbol: () => postChartAddSymbol,
+  getTicksRequestSymbol: () => getTicksRequestSymbol,
+  getTickInfoLastSymbol: () => getTickInfoLastSymbol,
+  getTickInfoLast: () => getTickInfoLast,
+  getPostHistoryCorrectSymbolUrl: () => getPostHistoryCorrectSymbolUrl,
+  getPostChartUpdateSymbolUrl: () => getPostChartUpdateSymbolUrl,
+  getPostChartDeleteSymbolUrl: () => getPostChartDeleteSymbolUrl,
+  getPostChartAddSymbolUrl: () => getPostChartAddSymbolUrl,
+  getGetTicksRequestSymbolUrl: () => getGetTicksRequestSymbolUrl,
+  getGetTickInfoLastUrl: () => getGetTickInfoLastUrl,
+  getGetTickInfoLastSymbolUrl: () => getGetTickInfoLastSymbolUrl,
+  getGetChartRequestSymbolUrl: () => getGetChartRequestSymbolUrl,
+  getChartRequestSymbol: () => getChartRequestSymbol
+});
+var getGetChartRequestSymbolUrl = (tradePlatform, symbol, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ChartRequest/${encodeURIComponent(String(symbol))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ChartRequest/${encodeURIComponent(String(symbol))}`;
+};
+var getChartRequestSymbol = async (tradePlatform, symbol, params, options) => {
+  return customFetch(getGetChartRequestSymbolUrl(tradePlatform, symbol, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostChartAddSymbolUrl = (tradePlatform, symbol, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ChartAdd/${encodeURIComponent(String(symbol))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ChartAdd/${encodeURIComponent(String(symbol))}`;
+};
+var postChartAddSymbol = async (tradePlatform, symbol, mT4ChartWriteRequest, params, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostChartAddSymbolUrl(tradePlatform, symbol, params), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4ChartWriteRequest)
+  });
+};
+var getPostChartUpdateSymbolUrl = (tradePlatform, symbol, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ChartUpdate/${encodeURIComponent(String(symbol))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ChartUpdate/${encodeURIComponent(String(symbol))}`;
+};
+var postChartUpdateSymbol = async (tradePlatform, symbol, mT4ChartWriteRequest, params, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostChartUpdateSymbolUrl(tradePlatform, symbol, params), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4ChartWriteRequest)
+  });
+};
+var getPostChartDeleteSymbolUrl = (tradePlatform, symbol, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ChartDelete/${encodeURIComponent(String(symbol))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ChartDelete/${encodeURIComponent(String(symbol))}`;
+};
+var postChartDeleteSymbol = async (tradePlatform, symbol, mT4ChartWriteRequest, params, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostChartDeleteSymbolUrl(tradePlatform, symbol, params), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4ChartWriteRequest)
+  });
+};
+var getPostHistoryCorrectSymbolUrl = (tradePlatform, symbol) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/HistoryCorrect/${encodeURIComponent(String(symbol))}`;
+};
+var postHistoryCorrectSymbol = async (tradePlatform, symbol, options) => {
+  return customFetch(getPostHistoryCorrectSymbolUrl(tradePlatform, symbol), {
+    ...options,
+    method: "POST"
+  });
+};
+var getGetTicksRequestSymbolUrl = (tradePlatform, symbol, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TicksRequest/${encodeURIComponent(String(symbol))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TicksRequest/${encodeURIComponent(String(symbol))}`;
+};
+var getTicksRequestSymbol = async (tradePlatform, symbol, params, options) => {
+  return customFetch(getGetTicksRequestSymbolUrl(tradePlatform, symbol, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTickInfoLastSymbolUrl = (tradePlatform, symbol) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TickInfoLast/${encodeURIComponent(String(symbol))}`;
+};
+var getTickInfoLastSymbol = async (tradePlatform, symbol, options) => {
+  return customFetch(getGetTickInfoLastSymbolUrl(tradePlatform, symbol), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTickInfoLastUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TickInfoLast`;
+};
+var getTickInfoLast = async (tradePlatform, options) => {
+  return customFetch(getGetTickInfoLastUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-reports.ts
+var exports_mt4_v2_reports = {};
+__export(exports_mt4_v2_reports, {
+  postDailySyncStart: () => postDailySyncStart,
+  postDailySyncRead: () => postDailySyncRead,
+  getReportsRequest: () => getReportsRequest,
+  getPostDailySyncStartUrl: () => getPostDailySyncStartUrl,
+  getPostDailySyncReadUrl: () => getPostDailySyncReadUrl,
+  getPerformanceRequest: () => getPerformanceRequest,
+  getGetReportsRequestUrl: () => getGetReportsRequestUrl,
+  getGetPerformanceRequestUrl: () => getGetPerformanceRequestUrl,
+  getGetDailyReportsRequestUrl: () => getGetDailyReportsRequestUrl,
+  getGetDailyReportsRequestExUrl: () => getGetDailyReportsRequestExUrl,
+  getDailyReportsRequestEx: () => getDailyReportsRequestEx,
+  getDailyReportsRequest: () => getDailyReportsRequest
+});
+var getGetPerformanceRequestUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/PerformanceRequest?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/PerformanceRequest`;
+};
+var getPerformanceRequest = async (tradePlatform, params, options) => {
+  return customFetch(getGetPerformanceRequestUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetReportsRequestUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["logins"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : String(v));
+      });
+      return;
+    }
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ReportsRequest?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ReportsRequest`;
+};
+var getReportsRequest = async (tradePlatform, params, options) => {
+  return customFetch(getGetReportsRequestUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetDailyReportsRequestUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["logins"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : String(v));
+      });
+      return;
+    }
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/DailyReportsRequest?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/DailyReportsRequest`;
+};
+var getDailyReportsRequest = async (tradePlatform, params, options) => {
+  return customFetch(getGetDailyReportsRequestUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetDailyReportsRequestExUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["logins"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : String(v));
+      });
+      return;
+    }
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/DailyReportsRequestEx?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/DailyReportsRequestEx`;
+};
+var getDailyReportsRequestEx = async (tradePlatform, params, options) => {
+  return customFetch(getGetDailyReportsRequestExUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostDailySyncStartUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/DailySyncStart?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/DailySyncStart`;
+};
+var postDailySyncStart = async (tradePlatform, params, options) => {
+  return customFetch(getPostDailySyncStartUrl(tradePlatform, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostDailySyncReadUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/DailySyncRead`;
+};
+var postDailySyncRead = async (tradePlatform, options) => {
+  return customFetch(getPostDailySyncReadUrl(tradePlatform), {
+    ...options,
+    method: "POST"
+  });
+};
+
+// src/generated/mt4-v2-server-admin-destructive.ts
+var exports_mt4_v2_server_admin_destructive = {};
+__export(exports_mt4_v2_server_admin_destructive, {
+  postSrvRestart: () => postSrvRestart,
+  postSrvLiveUpdateStart: () => postSrvLiveUpdateStart,
+  postSrvFeedsRestart: () => postSrvFeedsRestart,
+  postSrvChartsSync: () => postSrvChartsSync,
+  getPostSrvRestartUrl: () => getPostSrvRestartUrl,
+  getPostSrvLiveUpdateStartUrl: () => getPostSrvLiveUpdateStartUrl,
+  getPostSrvFeedsRestartUrl: () => getPostSrvFeedsRestartUrl,
+  getPostSrvChartsSyncUrl: () => getPostSrvChartsSyncUrl
+});
+var getPostSrvRestartUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvRestart?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvRestart`;
+};
+var postSrvRestart = async (tradePlatform, params, options) => {
+  return customFetch(getPostSrvRestartUrl(tradePlatform, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostSrvChartsSyncUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvChartsSync?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvChartsSync`;
+};
+var postSrvChartsSync = async (tradePlatform, params, options) => {
+  return customFetch(getPostSrvChartsSyncUrl(tradePlatform, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostSrvLiveUpdateStartUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvLiveUpdateStart?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvLiveUpdateStart`;
+};
+var postSrvLiveUpdateStart = async (tradePlatform, params, options) => {
+  return customFetch(getPostSrvLiveUpdateStartUrl(tradePlatform, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostSrvFeedsRestartUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvFeedsRestart?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvFeedsRestart`;
+};
+var postSrvFeedsRestart = async (tradePlatform, params, options) => {
+  return customFetch(getPostSrvFeedsRestartUrl(tradePlatform, params), {
+    ...options,
+    method: "POST"
+  });
+};
+
+// src/generated/mt4-v2-server-admin.ts
+var exports_mt4_v2_server_admin = {};
+__export(exports_mt4_v2_server_admin, {
+  postNotificationsSend: () => postNotificationsSend,
+  getSrvFeeders: () => getSrvFeeders,
+  getSrvFeederLogName: () => getSrvFeederLogName,
+  getPostNotificationsSendUrl: () => getPostNotificationsSendUrl,
+  getLicenseCheckLicenseName: () => getLicenseCheckLicenseName,
+  getGetSrvFeedersUrl: () => getGetSrvFeedersUrl,
+  getGetSrvFeederLogNameUrl: () => getGetSrvFeederLogNameUrl,
+  getGetLicenseCheckLicenseNameUrl: () => getGetLicenseCheckLicenseNameUrl
+});
+var getGetSrvFeedersUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvFeeders?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvFeeders`;
+};
+var getSrvFeeders = async (tradePlatform, params, options) => {
+  return customFetch(getGetSrvFeedersUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetLicenseCheckLicenseNameUrl = (tradePlatform, licenseName) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/LicenseCheck/${encodeURIComponent(String(licenseName))}`;
+};
+var getLicenseCheckLicenseName = async (tradePlatform, licenseName, options) => {
+  return customFetch(getGetLicenseCheckLicenseNameUrl(tradePlatform, licenseName), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostNotificationsSendUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/NotificationsSend`;
+};
+var postNotificationsSend = async (tradePlatform, mT4NotificationsSendRequest, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostNotificationsSendUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4NotificationsSendRequest)
+  });
+};
+var getGetSrvFeederLogNameUrl = (tradePlatform, name) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SrvFeederLog/${encodeURIComponent(String(name))}`;
+};
+var getSrvFeederLogName = async (tradePlatform, name, options) => {
+  return customFetch(getGetSrvFeederLogNameUrl(tradePlatform, name), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-symbols.ts
+var exports_mt4_v2_symbols = {};
+__export(exports_mt4_v2_symbols, {
+  postSymbolsRefresh: () => postSymbolsRefresh,
+  postSymbolSendTick: () => postSymbolSendTick,
+  postSymbolHideSymbol: () => postSymbolHideSymbol,
+  postSymbolChange: () => postSymbolChange,
+  postSymbolAddSymbol: () => postSymbolAddSymbol,
+  postCfgUpdateSymbolSymbol: () => postCfgUpdateSymbolSymbol,
+  patchSymbolConfigSymbol: () => patchSymbolConfigSymbol,
+  getSymbolsGroupsGet: () => getSymbolsGroupsGet,
+  getSymbolSessionsGetSymbol: () => getSymbolSessionsGetSymbol,
+  getSymbolInfoUpdated: () => getSymbolInfoUpdated,
+  getSymbolInfoGet: () => getSymbolInfoGet,
+  getPostSymbolsRefreshUrl: () => getPostSymbolsRefreshUrl,
+  getPostSymbolSendTickUrl: () => getPostSymbolSendTickUrl,
+  getPostSymbolHideSymbolUrl: () => getPostSymbolHideSymbolUrl,
+  getPostSymbolChangeUrl: () => getPostSymbolChangeUrl,
+  getPostSymbolAddSymbolUrl: () => getPostSymbolAddSymbolUrl,
+  getPostCfgUpdateSymbolSymbolUrl: () => getPostCfgUpdateSymbolSymbolUrl,
+  getPatchSymbolConfigSymbolUrl: () => getPatchSymbolConfigSymbolUrl,
+  getGetSymbolsGroupsGetUrl: () => getGetSymbolsGroupsGetUrl,
+  getGetSymbolSessionsGetSymbolUrl: () => getGetSymbolSessionsGetSymbolUrl,
+  getGetSymbolInfoUpdatedUrl: () => getGetSymbolInfoUpdatedUrl,
+  getGetSymbolInfoGetUrl: () => getGetSymbolInfoGetUrl,
+  getGetCfgRequestSymbolUrl: () => getGetCfgRequestSymbolUrl,
+  getGetCfgRequestSymbolSymbolUrl: () => getGetCfgRequestSymbolSymbolUrl,
+  getCfgRequestSymbolSymbol: () => getCfgRequestSymbolSymbol,
+  getCfgRequestSymbol: () => getCfgRequestSymbol
+});
+var getGetSymbolInfoGetUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolInfoGet?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolInfoGet`;
+};
+var getSymbolInfoGet = async (tradePlatform, params, options) => {
+  return customFetch(getGetSymbolInfoGetUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetSymbolInfoUpdatedUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolInfoUpdated?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolInfoUpdated`;
+};
+var getSymbolInfoUpdated = async (tradePlatform, params, options) => {
+  return customFetch(getGetSymbolInfoUpdatedUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetSymbolsGroupsGetUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolsGroupsGet`;
+};
+var getSymbolsGroupsGet = async (tradePlatform, options) => {
+  return customFetch(getGetSymbolsGroupsGetUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestSymbolUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestSymbol`;
+};
+var getCfgRequestSymbol = async (tradePlatform, options) => {
+  return customFetch(getGetCfgRequestSymbolUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCfgRequestSymbolSymbolUrl = (tradePlatform, symbol) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestSymbol/${encodeURIComponent(String(symbol))}`;
+};
+var getCfgRequestSymbolSymbol = async (tradePlatform, symbol, options) => {
+  return customFetch(getGetCfgRequestSymbolSymbolUrl(tradePlatform, symbol), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetSymbolSessionsGetSymbolUrl = (tradePlatform, symbol) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolSessionsGet/${encodeURIComponent(String(symbol))}`;
+};
+var getSymbolSessionsGetSymbol = async (tradePlatform, symbol, options) => {
+  return customFetch(getGetSymbolSessionsGetSymbolUrl(tradePlatform, symbol), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostCfgUpdateSymbolSymbolUrl = (tradePlatform, symbol) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdateSymbol/${encodeURIComponent(String(symbol))}`;
+};
+var postCfgUpdateSymbolSymbol = async (tradePlatform, symbol, mT4SymbolConfigUpdate, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdateSymbolSymbolUrl(tradePlatform, symbol), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4SymbolConfigUpdate)
+  });
+};
+var getPatchSymbolConfigSymbolUrl = (tradePlatform, symbol) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolConfig/${encodeURIComponent(String(symbol))}`;
+};
+var patchSymbolConfigSymbol = async (tradePlatform, symbol, patchSymbolConfigSymbolBody, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPatchSymbolConfigSymbolUrl(tradePlatform, symbol), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(patchSymbolConfigSymbolBody)
+  });
+};
+var getPostSymbolAddSymbolUrl = (tradePlatform, symbol) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolAdd/${encodeURIComponent(String(symbol))}`;
+};
+var postSymbolAddSymbol = async (tradePlatform, symbol, options) => {
+  return customFetch(getPostSymbolAddSymbolUrl(tradePlatform, symbol), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostSymbolHideSymbolUrl = (tradePlatform, symbol) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolHide/${encodeURIComponent(String(symbol))}`;
+};
+var postSymbolHideSymbol = async (tradePlatform, symbol, options) => {
+  return customFetch(getPostSymbolHideSymbolUrl(tradePlatform, symbol), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostSymbolsRefreshUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolsRefresh`;
+};
+var postSymbolsRefresh = async (tradePlatform, options) => {
+  return customFetch(getPostSymbolsRefreshUrl(tradePlatform), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostSymbolChangeUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolChange`;
+};
+var postSymbolChange = async (tradePlatform, mT4SymbolChangeRequest, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostSymbolChangeUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4SymbolChangeRequest)
+  });
+};
+var getPostSymbolSendTickUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolSendTick?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/SymbolSendTick`;
+};
+var postSymbolSendTick = async (tradePlatform, params, options) => {
+  return customFetch(getPostSymbolSendTickUrl(tradePlatform, params), {
+    ...options,
+    method: "POST"
+  });
+};
+
+// src/generated/mt4-v2-trades.ts
+var exports_mt4_v2_trades = {};
+__export(exports_mt4_v2_trades, {
+  postTradesSyncStart: () => postTradesSyncStart,
+  postTradeTransaction: () => postTradeTransaction,
+  postTradeClearRollbackOrder: () => postTradeClearRollbackOrder,
+  postTradeCheckStops: () => postTradeCheckStops,
+  postAdmTradesDelete: () => postAdmTradesDelete,
+  postAdmTradeRecordModifyTicket: () => postAdmTradeRecordModifyTicket,
+  getTradesRequest: () => getTradesRequest,
+  getTradesGetTicket: () => getTradesGetTicket,
+  getTradesGetBySymbol: () => getTradesGetBySymbol,
+  getTradesGetByMarket: () => getTradesGetByMarket,
+  getTradesGetByLoginLoginGroup: () => getTradesGetByLoginLoginGroup,
+  getTradesGet: () => getTradesGet,
+  getTradeRecordsRequest: () => getTradeRecordsRequest,
+  getTradeRecordRequestOrder: () => getTradeRecordRequestOrder,
+  getTradeRecordGetOrder: () => getTradeRecordGetOrder,
+  getPostTradesSyncStartUrl: () => getPostTradesSyncStartUrl,
+  getPostTradeTransactionUrl: () => getPostTradeTransactionUrl,
+  getPostTradeClearRollbackOrderUrl: () => getPostTradeClearRollbackOrderUrl,
+  getPostTradeCheckStopsUrl: () => getPostTradeCheckStopsUrl,
+  getPostAdmTradesDeleteUrl: () => getPostAdmTradesDeleteUrl,
+  getPostAdmTradeRecordModifyTicketUrl: () => getPostAdmTradeRecordModifyTicketUrl,
+  getGetTradesRequestUrl: () => getGetTradesRequestUrl,
+  getGetTradesGetUrl: () => getGetTradesGetUrl,
+  getGetTradesGetTicketUrl: () => getGetTradesGetTicketUrl,
+  getGetTradesGetBySymbolUrl: () => getGetTradesGetBySymbolUrl,
+  getGetTradesGetByMarketUrl: () => getGetTradesGetByMarketUrl,
+  getGetTradesGetByLoginLoginGroupUrl: () => getGetTradesGetByLoginLoginGroupUrl,
+  getGetTradeRecordsRequestUrl: () => getGetTradeRecordsRequestUrl,
+  getGetTradeRecordRequestOrderUrl: () => getGetTradeRecordRequestOrderUrl,
+  getGetTradeRecordGetOrderUrl: () => getGetTradeRecordGetOrderUrl,
+  getGetAdmTradesRequestGroupUrl: () => getGetAdmTradesRequestGroupUrl,
+  getAdmTradesRequestGroup: () => getAdmTradesRequestGroup
+});
+var getGetTradesGetUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesGet?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesGet`;
+};
+var getTradesGet = async (tradePlatform, params, options) => {
+  return customFetch(getGetTradesGetUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTradesGetTicketUrl = (tradePlatform, ticket) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesGet/${encodeURIComponent(String(ticket))}`;
+};
+var getTradesGetTicket = async (tradePlatform, ticket, options) => {
+  return customFetch(getGetTradesGetTicketUrl(tradePlatform, ticket), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTradesGetByLoginLoginGroupUrl = (tradePlatform, login, group) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesGetByLogin/${encodeURIComponent(String(login))}/${encodeURIComponent(String(group))}`;
+};
+var getTradesGetByLoginLoginGroup = async (tradePlatform, login, group, options) => {
+  return customFetch(getGetTradesGetByLoginLoginGroupUrl(tradePlatform, login, group), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTradesGetBySymbolUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesGetBySymbol?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesGetBySymbol`;
+};
+var getTradesGetBySymbol = async (tradePlatform, params, options) => {
+  return customFetch(getGetTradesGetBySymbolUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTradesGetByMarketUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesGetByMarket`;
+};
+var getTradesGetByMarket = async (tradePlatform, options) => {
+  return customFetch(getGetTradesGetByMarketUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTradeRecordGetOrderUrl = (tradePlatform, order) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradeRecordGet/${encodeURIComponent(String(order))}`;
+};
+var getTradeRecordGetOrder = async (tradePlatform, order, options) => {
+  return customFetch(getGetTradeRecordGetOrderUrl(tradePlatform, order), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostTradeCheckStopsUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradeCheckStops?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradeCheckStops`;
+};
+var postTradeCheckStops = async (tradePlatform, mT4TradeTransaction, params, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostTradeCheckStopsUrl(tradePlatform, params), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4TradeTransaction)
+  });
+};
+var getPostTradeClearRollbackOrderUrl = (tradePlatform, order) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradeClearRollback/${encodeURIComponent(String(order))}`;
+};
+var postTradeClearRollbackOrder = async (tradePlatform, order, options) => {
+  return customFetch(getPostTradeClearRollbackOrderUrl(tradePlatform, order), {
+    ...options,
+    method: "POST"
+  });
+};
+var getGetTradeRecordRequestOrderUrl = (tradePlatform, order) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradeRecordRequest/${encodeURIComponent(String(order))}`;
+};
+var getTradeRecordRequestOrder = async (tradePlatform, order, options) => {
+  return customFetch(getGetTradeRecordRequestOrderUrl(tradePlatform, order), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTradesRequestUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesRequest?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesRequest`;
+};
+var getTradesRequest = async (tradePlatform, params, options) => {
+  return customFetch(getGetTradesRequestUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostAdmTradeRecordModifyTicketUrl = (tradePlatform, ticket) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmTradeRecordModify/${encodeURIComponent(String(ticket))}`;
+};
+var postAdmTradeRecordModifyTicket = async (tradePlatform, ticket, mT4TradeUpdate, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostAdmTradeRecordModifyTicketUrl(tradePlatform, ticket), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4TradeUpdate)
+  });
+};
+var getPostTradeTransactionUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradeTransaction`;
+};
+var postTradeTransaction = async (tradePlatform, mT4TradeTransaction, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostTradeTransactionUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4TradeTransaction)
+  });
+};
+var getGetTradeRecordsRequestUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["orders"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : String(v));
+      });
+      return;
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradeRecordsRequest?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradeRecordsRequest`;
+};
+var getTradeRecordsRequest = async (tradePlatform, params, options) => {
+  return customFetch(getGetTradeRecordsRequestUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetAdmTradesRequestGroupUrl = (tradePlatform, group, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmTradesRequest/${encodeURIComponent(String(group))}?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmTradesRequest/${encodeURIComponent(String(group))}`;
+};
+var getAdmTradesRequestGroup = async (tradePlatform, group, params, options) => {
+  return customFetch(getGetAdmTradesRequestGroupUrl(tradePlatform, group, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostAdmTradesDeleteUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["orders"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : String(v));
+      });
+      return;
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmTradesDelete?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmTradesDelete`;
+};
+var postAdmTradesDelete = async (tradePlatform, params, options) => {
+  return customFetch(getPostAdmTradesDeleteUrl(tradePlatform, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostTradesSyncStartUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesSyncStart?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesSyncStart`;
+};
+var postTradesSyncStart = async (tradePlatform, params, options) => {
+  return customFetch(getPostTradesSyncStartUrl(tradePlatform, params), {
+    ...options,
+    method: "POST"
+  });
+};
+
+// src/generated/mt4-v2-users.ts
+var exports_mt4_v2_users = {};
+__export(exports_mt4_v2_users, {
+  postUsersSyncStart: () => postUsersSyncStart,
+  postUsersGroupOp: () => postUsersGroupOp,
+  postUserRecordUpdateLogin: () => postUserRecordUpdateLogin,
+  postUserRecordNew: () => postUserRecordNew,
+  postAdmBalanceFix: () => postAdmBalanceFix,
+  patchUserRecordLoginMT4: () => patchUserRecordLoginMT4,
+  getUsersRequest: () => getUsersRequest,
+  getUserRecordsRequest: () => getUserRecordsRequest,
+  getUserRecordRequestLogin: () => getUserRecordRequestLogin,
+  getUserRecordGetLogin: () => getUserRecordGetLogin,
+  getPostUsersSyncStartUrl: () => getPostUsersSyncStartUrl,
+  getPostUsersGroupOpUrl: () => getPostUsersGroupOpUrl,
+  getPostUserRecordUpdateLoginUrl: () => getPostUserRecordUpdateLoginUrl,
+  getPostUserRecordNewUrl: () => getPostUserRecordNewUrl,
+  getPostAdmBalanceFixUrl: () => getPostAdmBalanceFixUrl,
+  getPatchUserRecordLoginMT4Url: () => getPatchUserRecordLoginMT4Url,
+  getGetUsersRequestUrl: () => getGetUsersRequestUrl,
+  getGetUserRecordsRequestUrl: () => getGetUserRecordsRequestUrl,
+  getGetUserRecordRequestLoginUrl: () => getGetUserRecordRequestLoginUrl,
+  getGetUserRecordGetLoginUrl: () => getGetUserRecordGetLoginUrl,
+  getGetAdmUsersRequestSafeGroupUrl: () => getGetAdmUsersRequestSafeGroupUrl,
+  getGetAdmBalanceCheckUrl: () => getGetAdmBalanceCheckUrl,
+  getGetAdmBalanceCheckLoginUrl: () => getGetAdmBalanceCheckLoginUrl,
+  getAdmUsersRequestSafeGroup: () => getAdmUsersRequestSafeGroup,
+  getAdmBalanceCheckLogin: () => getAdmBalanceCheckLogin,
+  getAdmBalanceCheck: () => getAdmBalanceCheck
+});
+var getGetUserRecordGetLoginUrl = (tradePlatform, login) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UserRecordGet/${encodeURIComponent(String(login))}`;
+};
+var getUserRecordGetLogin = async (tradePlatform, login, options) => {
+  return customFetch(getGetUserRecordGetLoginUrl(tradePlatform, login), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetUserRecordRequestLoginUrl = (tradePlatform, login) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UserRecordRequest/${encodeURIComponent(String(login))}`;
+};
+var getUserRecordRequestLogin = async (tradePlatform, login, options) => {
+  return customFetch(getGetUserRecordRequestLoginUrl(tradePlatform, login), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetUserRecordsRequestUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["logins"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : String(v));
+      });
+      return;
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UserRecordsRequest?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UserRecordsRequest`;
+};
+var getUserRecordsRequest = async (tradePlatform, params, options) => {
+  return customFetch(getGetUserRecordsRequestUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetAdmBalanceCheckLoginUrl = (tradePlatform, login) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmBalanceCheck/${encodeURIComponent(String(login))}`;
+};
+var getAdmBalanceCheckLogin = async (tradePlatform, login, options) => {
+  return customFetch(getGetAdmBalanceCheckLoginUrl(tradePlatform, login), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetAdmBalanceCheckUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["logins"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : String(v));
+      });
+      return;
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmBalanceCheck?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmBalanceCheck`;
+};
+var getAdmBalanceCheck = async (tradePlatform, params, options) => {
+  return customFetch(getGetAdmBalanceCheckUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostAdmBalanceFixUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["logins"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : String(v));
+      });
+      return;
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmBalanceFix?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmBalanceFix`;
+};
+var postAdmBalanceFix = async (tradePlatform, params, options) => {
+  return customFetch(getPostAdmBalanceFixUrl(tradePlatform, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getGetUsersRequestUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UsersRequest?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UsersRequest`;
+};
+var getUsersRequest = async (tradePlatform, params, options) => {
+  return customFetch(getGetUsersRequestUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostUserRecordNewUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UserRecordNew`;
+};
+var postUserRecordNew = async (tradePlatform, mT4UserCreate, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostUserRecordNewUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4UserCreate)
+  });
+};
+var getPostUserRecordUpdateLoginUrl = (tradePlatform, login) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UserRecordUpdate/${encodeURIComponent(String(login))}`;
+};
+var postUserRecordUpdateLogin = async (tradePlatform, login, mT4UserUpdate, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostUserRecordUpdateLoginUrl(tradePlatform, login), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4UserUpdate)
+  });
+};
+var getPatchUserRecordLoginMT4Url = (tradePlatform, login) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UserRecord/${encodeURIComponent(String(login))}`;
+};
+var patchUserRecordLoginMT4 = async (tradePlatform, login, patchUserRecordLoginMT4Body, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPatchUserRecordLoginMT4Url(tradePlatform, login), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(patchUserRecordLoginMT4Body)
+  });
+};
+var getGetAdmUsersRequestSafeGroupUrl = (tradePlatform, group) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/AdmUsersRequestSafe/${encodeURIComponent(String(group))}`;
+};
+var getAdmUsersRequestSafeGroup = async (tradePlatform, group, options) => {
+  return customFetch(getGetAdmUsersRequestSafeGroupUrl(tradePlatform, group), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostUsersSyncStartUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UsersSyncStart?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UsersSyncStart`;
+};
+var postUsersSyncStart = async (tradePlatform, params, options) => {
+  return customFetch(getPostUsersSyncStartUrl(tradePlatform, params), {
+    ...options,
+    method: "POST"
+  });
+};
+var getPostUsersGroupOpUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UsersGroupOp`;
+};
+var postUsersGroupOp = async (tradePlatform, mT4UsersGroupOp, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostUsersGroupOpUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4UsersGroupOp)
+  });
+};
+
+// src/generated/mt4-v2-sidecar-messaging.ts
+var exports_mt4_v2_sidecar_messaging = {};
+__export(exports_mt4_v2_sidecar_messaging, {
+  postNewsSend: () => postNewsSend,
+  postMailSend: () => postMailSend,
+  getPostNewsSendUrl: () => getPostNewsSendUrl,
+  getPostMailSendUrl: () => getPostMailSendUrl,
+  getMailsRequest: () => getMailsRequest,
+  getGetMailsRequestUrl: () => getGetMailsRequestUrl
+});
+var getPostNewsSendUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/NewsSend`;
+};
+var postNewsSend = async (tradePlatform, mT4NewsSendRequest, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostNewsSendUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4NewsSendRequest)
+  });
+};
+var getPostMailSendUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/MailSend`;
+};
+var postMailSend = async (tradePlatform, mT4MailSendRequest, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostMailSendUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4MailSendRequest)
+  });
+};
+var getGetMailsRequestUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/MailsRequest`;
+};
+var getMailsRequest = async (tradePlatform, options) => {
+  return customFetch(getGetMailsRequestUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-sidecar-plugins.ts
+var exports_mt4_v2_sidecar_plugins = {};
+__export(exports_mt4_v2_sidecar_plugins, {
+  postPluginUpdate: () => postPluginUpdate,
+  postCfgUpdatePlugin: () => postCfgUpdatePlugin,
+  getPostPluginUpdateUrl: () => getPostPluginUpdateUrl,
+  getPostCfgUpdatePluginUrl: () => getPostCfgUpdatePluginUrl,
+  getPluginsGet: () => getPluginsGet,
+  getPluginParamGetPos: () => getPluginParamGetPos,
+  getGetPluginsGetUrl: () => getGetPluginsGetUrl,
+  getGetPluginParamGetPosUrl: () => getGetPluginParamGetPosUrl,
+  getGetCfgRequestPluginUrl: () => getGetCfgRequestPluginUrl,
+  getCfgRequestPlugin: () => getCfgRequestPlugin
+});
+var getGetPluginsGetUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/PluginsGet`;
+};
+var getPluginsGet = async (tradePlatform, options) => {
+  return customFetch(getGetPluginsGetUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetPluginParamGetPosUrl = (tradePlatform, pos) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/PluginParamGet/${encodeURIComponent(String(pos))}`;
+};
+var getPluginParamGetPos = async (tradePlatform, pos, options) => {
+  return customFetch(getGetPluginParamGetPosUrl(tradePlatform, pos), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostPluginUpdateUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/PluginUpdate`;
+};
+var postPluginUpdate = async (tradePlatform, mT4PluginParam, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostPluginUpdateUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4PluginParam)
+  });
+};
+var getGetCfgRequestPluginUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgRequestPlugin`;
+};
+var getCfgRequestPlugin = async (tradePlatform, options) => {
+  return customFetch(getGetCfgRequestPluginUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPostCfgUpdatePluginUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/CfgUpdatePlugin`;
+};
+var postCfgUpdatePlugin = async (tradePlatform, mT4PluginParam, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostCfgUpdatePluginUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4PluginParam)
+  });
+};
+
+// src/generated/mt4-v2-sidecar-batch-reads.ts
+var exports_mt4_v2_sidecar_batch_reads = {};
+__export(exports_mt4_v2_sidecar_batch_reads, {
+  getUsersSyncRead: () => getUsersSyncRead,
+  getUsersSnapshot: () => getUsersSnapshot,
+  getTradesSyncRead: () => getTradesSyncRead,
+  getTradesSnapshot: () => getTradesSnapshot,
+  getGetUsersSyncReadUrl: () => getGetUsersSyncReadUrl,
+  getGetUsersSnapshotUrl: () => getGetUsersSnapshotUrl,
+  getGetTradesSyncReadUrl: () => getGetTradesSyncReadUrl,
+  getGetTradesSnapshotUrl: () => getGetTradesSnapshotUrl
+});
+var getGetUsersSnapshotUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UsersSnapshot?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UsersSnapshot`;
+};
+var getUsersSnapshot = async (tradePlatform, params, options) => {
+  return customFetch(getGetUsersSnapshotUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetUsersSyncReadUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UsersSyncRead?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/UsersSyncRead`;
+};
+var getUsersSyncRead = async (tradePlatform, params, options) => {
+  return customFetch(getGetUsersSyncReadUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTradesSnapshotUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesSnapshot?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesSnapshot`;
+};
+var getTradesSnapshot = async (tradePlatform, params, options) => {
+  return customFetch(getGetTradesSnapshotUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTradesSyncReadUrl = (tradePlatform, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesSyncRead?${stringifiedParams}` : `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/TradesSyncRead`;
+};
+var getTradesSyncRead = async (tradePlatform, params, options) => {
+  return customFetch(getGetTradesSyncReadUrl(tradePlatform, params), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt4-v2-sidecar-externalcommand.ts
+var exports_mt4_v2_sidecar_externalcommand = {};
+__export(exports_mt4_v2_sidecar_externalcommand, {
+  postExternalCommandBinary: () => postExternalCommandBinary,
+  getPostExternalCommandBinaryUrl: () => getPostExternalCommandBinaryUrl
+});
+var getPostExternalCommandBinaryUrl = (tradePlatform) => {
+  return `/api/v2/MT4/${encodeURIComponent(String(tradePlatform))}/ExternalCommandBinary`;
+};
+var postExternalCommandBinary = async (tradePlatform, mT4ExternalCommandBinaryRequest, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPostExternalCommandBinaryUrl(tradePlatform), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json-patch+json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(mT4ExternalCommandBinaryRequest)
+  });
+};
+
+// src/generated/mt5-v2-common.ts
+var exports_mt5_v2_common = {};
+__export(exports_mt5_v2_common, {
+  getTimeGet: () => getTimeGet,
+  getServerTimeMT5: () => getServerTimeMT5,
+  getGetTimeGetUrl: () => getGetTimeGetUrl,
+  getGetServerTimeMT5Url: () => getGetServerTimeMT5Url
+});
+var getGetServerTimeMT5Url = (tradePlatform) => {
+  return `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/ServerTime`;
+};
+var getServerTimeMT5 = async (tradePlatform, options) => {
+  return customFetch(getGetServerTimeMT5Url(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetTimeGetUrl = (tradePlatform) => {
+  return `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/TimeGet`;
+};
+var getTimeGet = async (tradePlatform, options) => {
+  return customFetch(getGetTimeGetUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt5-v2-groups.ts
+var exports_mt5_v2_groups = {};
+__export(exports_mt5_v2_groups, {
+  patchGroupRecordGroupMT5: () => patchGroupRecordGroupMT5,
+  getPatchGroupRecordGroupMT5Url: () => getPatchGroupRecordGroupMT5Url,
+  getGroupGetGroup: () => getGroupGetGroup,
+  getGetGroupGetGroupUrl: () => getGetGroupGetGroupUrl
+});
+var getGetGroupGetGroupUrl = (tradePlatform, group) => {
+  return `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/GroupGet/${encodeURIComponent(String(group))}`;
+};
+var getGroupGetGroup = async (tradePlatform, group, options) => {
+  return customFetch(getGetGroupGetGroupUrl(tradePlatform, group), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPatchGroupRecordGroupMT5Url = (tradePlatform, group) => {
+  return `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/GroupRecord/${encodeURIComponent(String(group))}`;
+};
+var patchGroupRecordGroupMT5 = async (tradePlatform, group, patchGroupRecordGroupMT5Body, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPatchGroupRecordGroupMT5Url(tradePlatform, group), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(patchGroupRecordGroupMT5Body)
+  });
+};
+
+// src/generated/mt5-v2-managers.ts
+var exports_mt5_v2_managers = {};
+__export(exports_mt5_v2_managers, {
+  getManagerCurrent: () => getManagerCurrent,
+  getGetManagerCurrentUrl: () => getGetManagerCurrentUrl
+});
+var getGetManagerCurrentUrl = (tradePlatform) => {
+  return `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/ManagerCurrent`;
+};
+var getManagerCurrent = async (tradePlatform, options) => {
+  return customFetch(getGetManagerCurrentUrl(tradePlatform), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt5-v2-symbols.ts
+var exports_mt5_v2_symbols = {};
+__export(exports_mt5_v2_symbols, {
+  patchSymbolRecordSymbol: () => patchSymbolRecordSymbol,
+  getSymbolGetSymbol: () => getSymbolGetSymbol,
+  getPatchSymbolRecordSymbolUrl: () => getPatchSymbolRecordSymbolUrl,
+  getGetSymbolGetSymbolUrl: () => getGetSymbolGetSymbolUrl
+});
+var getGetSymbolGetSymbolUrl = (tradePlatform, symbol) => {
+  return `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/SymbolGet/${encodeURIComponent(String(symbol))}`;
+};
+var getSymbolGetSymbol = async (tradePlatform, symbol, options) => {
+  return customFetch(getGetSymbolGetSymbolUrl(tradePlatform, symbol), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPatchSymbolRecordSymbolUrl = (tradePlatform, symbol) => {
+  return `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/SymbolRecord/${encodeURIComponent(String(symbol))}`;
+};
+var patchSymbolRecordSymbol = async (tradePlatform, symbol, patchSymbolRecordSymbolBody, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPatchSymbolRecordSymbolUrl(tradePlatform, symbol), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(patchSymbolRecordSymbolBody)
+  });
+};
+
+// src/generated/mt5-v2-trades.ts
+var exports_mt5_v2_trades = {};
+__export(exports_mt5_v2_trades, {
+  getPositionByGroupMask: () => getPositionByGroupMask,
+  getOrderByGroupMask: () => getOrderByGroupMask,
+  getGetPositionByGroupMaskUrl: () => getGetPositionByGroupMaskUrl,
+  getGetOrderByGroupMaskUrl: () => getGetOrderByGroupMaskUrl,
+  getGetDealByGroupMaskUrl: () => getGetDealByGroupMaskUrl,
+  getDealByGroupMask: () => getDealByGroupMask
+});
+var getGetPositionByGroupMaskUrl = (tradePlatform, mask, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/PositionByGroup/${encodeURIComponent(String(mask))}?${stringifiedParams}` : `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/PositionByGroup/${encodeURIComponent(String(mask))}`;
+};
+var getPositionByGroupMask = async (tradePlatform, mask, params, options) => {
+  return customFetch(getGetPositionByGroupMaskUrl(tradePlatform, mask, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetOrderByGroupMaskUrl = (tradePlatform, mask, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/OrderByGroup/${encodeURIComponent(String(mask))}?${stringifiedParams}` : `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/OrderByGroup/${encodeURIComponent(String(mask))}`;
+};
+var getOrderByGroupMask = async (tradePlatform, mask, params, options) => {
+  return customFetch(getGetOrderByGroupMaskUrl(tradePlatform, mask, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetDealByGroupMaskUrl = (tradePlatform, mask, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : String(value));
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/DealByGroup/${encodeURIComponent(String(mask))}?${stringifiedParams}` : `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/DealByGroup/${encodeURIComponent(String(mask))}`;
+};
+var getDealByGroupMask = async (tradePlatform, mask, params, options) => {
+  return customFetch(getGetDealByGroupMaskUrl(tradePlatform, mask, params), {
+    ...options,
+    method: "GET"
+  });
+};
+
+// src/generated/mt5-v2-users.ts
+var exports_mt5_v2_users = {};
+__export(exports_mt5_v2_users, {
+  patchUserRecordLoginMT5: () => patchUserRecordLoginMT5,
+  getUserGetLogin: () => getUserGetLogin,
+  getPatchUserRecordLoginMT5Url: () => getPatchUserRecordLoginMT5Url,
+  getGetUserGetLoginUrl: () => getGetUserGetLoginUrl
+});
+var getGetUserGetLoginUrl = (tradePlatform, login) => {
+  return `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/UserGet/${encodeURIComponent(String(login))}`;
+};
+var getUserGetLogin = async (tradePlatform, login, options) => {
+  return customFetch(getGetUserGetLoginUrl(tradePlatform, login), {
+    ...options,
+    method: "GET"
+  });
+};
+var getPatchUserRecordLoginMT5Url = (tradePlatform, login) => {
+  return `/api/v2/MT5/${encodeURIComponent(String(tradePlatform))}/UserRecord/${encodeURIComponent(String(login))}`;
+};
+var patchUserRecordLoginMT5 = async (tradePlatform, login, patchUserRecordLoginMT5Body, options) => {
+  const getHeaders = (h) => {
+    if (!h)
+      return {};
+    if (h instanceof Headers)
+      return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(h)) {
+      if (value !== undefined)
+        headers[name] = value;
+    }
+    return headers;
+  };
+  return customFetch(getPatchUserRecordLoginMT5Url(tradePlatform, login), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+    body: JSON.stringify(patchUserRecordLoginMT5Body)
+  });
+};
+
+// src/client.ts
+function bind(mod, base, platformSuffix) {
+  const out = {};
+  for (const [name, value] of Object.entries(mod)) {
+    const key = platformSuffix && name.endsWith(platformSuffix) ? name.slice(0, -platformSuffix.length) : name;
+    if (typeof value !== "function") {
+      out[key] = value;
+      continue;
+    }
+    out[key] = (...args) => {
+      const callArgs = [...args];
+      const optionsIndex = value.length - 1;
+      while (callArgs.length < optionsIndex)
+        callArgs.push(undefined);
+      callArgs[optionsIndex] = withRequestContext(callArgs[optionsIndex], base);
+      return value(...callArgs);
+    };
+  }
+  return out;
+}
+
+class CPluginWebApiClient {
+  mt4;
+  mt5;
+  realtime;
+  base;
+  constructor(init) {
+    const env = resolveEnvironment(init);
+    const tokenProvider = new ClientCredentialsTokenProvider({
+      clientId: init.clientId,
+      clientSecret: init.clientSecret,
+      identityUrl: env.authority,
+      ...init.scopes ? { scopes: init.scopes } : {},
+      ...init.fetch ? { fetch: init.fetch } : {},
+      ...init.timeoutMs !== undefined ? { timeoutMs: init.timeoutMs } : {},
+      ...env.allowInsecureLoopback ? { allowInsecureLoopback: true } : {}
+    });
+    this.base = {
+      apiBaseUrl: env.apiBaseUrl,
+      tokenProvider,
+      fetchImpl: init.fetch ?? globalThis.fetch.bind(globalThis),
+      retryPolicy: { ...defaultPolicy, ...init.retry ?? {} },
+      timeoutMs: init.timeoutMs ?? 30000,
+      ...init.requestTimeout !== undefined ? { requestTimeout: validateRequestTimeout(init.requestTimeout) } : {}
+    };
+    if (!Number.isFinite(this.base.timeoutMs) || this.base.timeoutMs <= 0) {
+      throw new TypeError("timeoutMs must be a positive finite number");
+    }
+    this.mt4 = {
+      ...bind(exports_mt4_v2_authentication, this.base, "MT4"),
+      ...bind(exports_mt4_v2_backup_destructive, this.base, "MT4"),
+      ...bind(exports_mt4_v2_backup, this.base, "MT4"),
+      ...bind(exports_mt4_v2_common, this.base, "MT4"),
+      ...bind(exports_mt4_v2_config, this.base, "MT4"),
+      ...bind(exports_mt4_v2_groups, this.base, "MT4"),
+      ...bind(exports_mt4_v2_history, this.base, "MT4"),
+      ...bind(exports_mt4_v2_mail, this.base, "MT4"),
+      ...bind(exports_mt4_v2_margins, this.base, "MT4"),
+      ...bind(exports_mt4_v2_news, this.base, "MT4"),
+      ...bind(exports_mt4_v2_online, this.base, "MT4"),
+      ...bind(exports_mt4_v2_plugins, this.base, "MT4"),
+      ...bind(exports_mt4_v2_prices, this.base, "MT4"),
+      ...bind(exports_mt4_v2_reports, this.base, "MT4"),
+      ...bind(exports_mt4_v2_server_admin_destructive, this.base, "MT4"),
+      ...bind(exports_mt4_v2_server_admin, this.base, "MT4"),
+      ...bind(exports_mt4_v2_symbols, this.base, "MT4"),
+      ...bind(exports_mt4_v2_trades, this.base, "MT4"),
+      ...bind(exports_mt4_v2_users, this.base, "MT4"),
+      ...bind(exports_mt4_v2_sidecar_messaging, this.base, "MT4"),
+      ...bind(exports_mt4_v2_sidecar_plugins, this.base, "MT4"),
+      ...bind(exports_mt4_v2_sidecar_batch_reads, this.base, "MT4"),
+      ...bind(exports_mt4_v2_sidecar_externalcommand, this.base, "MT4")
+    };
+    this.mt5 = {
+      ...bind(exports_mt5_v2_common, this.base, "MT5"),
+      ...bind(exports_mt5_v2_groups, this.base, "MT5"),
+      ...bind(exports_mt5_v2_managers, this.base, "MT5"),
+      ...bind(exports_mt5_v2_symbols, this.base, "MT5"),
+      ...bind(exports_mt5_v2_trades, this.base, "MT5"),
+      ...bind(exports_mt5_v2_users, this.base, "MT5")
+    };
+    const base = this.base;
+    this.realtime = {
+      mt4: (tradePlatform, extras) => new MT4V2SignalRClient({
+        tokenProvider: base.tokenProvider,
+        baseUrl: base.apiBaseUrl,
+        tradePlatform,
+        ...extras ?? {}
+      }),
+      mt5: (tradePlatform, extras) => new MT5V2SignalRClient({
+        tokenProvider: base.tokenProvider,
+        baseUrl: base.apiBaseUrl,
+        tradePlatform,
+        ...extras ?? {}
+      })
+    };
+  }
+  async paged(call) {
+    const items = await call();
+    return {
+      items: Array.isArray(items) ? items : [],
+      paging: pagingFromResult(items)?.paging ?? null
+    };
+  }
+  async listTradePlatforms() {
+    return authenticatedFetch(this.base, "/api/TradePlatforms", { method: "GET" }, async (response, signal) => {
+      if (!response.ok) {
+        throw new ApiError({ code: codeForHttpStatus(response.status), message: "GET /api/TradePlatforms returned HTTP " + response.status }, null, response.status);
+      }
+      let payload;
+      try {
+        payload = await response.json();
+      } catch (error) {
+        if (signal.aborted)
+          throw signal.reason ?? error;
+        throw new ApiError({ code: "Internal", message: "GET /api/TradePlatforms returned malformed JSON" }, null, response.status);
+      }
+      if (!Array.isArray(payload)) {
+        throw new ApiError({ code: "Internal", message: "GET /api/TradePlatforms returned an invalid payload" }, null, response.status);
+      }
+      return payload;
+    });
+  }
+}
+// src/pagination.ts
+async function* paginate(fetchPage) {
+  let cursor = undefined;
+  while (true) {
+    const page = await fetchPage(cursor);
+    yield page.items;
+    if (!page.paging?.hasMore)
+      return;
+    cursor = page.paging.nextCursor ?? undefined;
+    if (!cursor)
+      return;
+  }
+}
+async function collectAll(fetchPage) {
+  const all = [];
+  for await (const page of paginate(fetchPage))
+    all.push(...page);
+  return all;
+}
+export {
+  resolveEnvironment,
+  paginate,
+  isRetryable,
+  isOutcomeUnknown,
+  defaultPolicy,
+  collectAll,
+  StaticTokenProvider,
+  SERVER_ANSWER_MARGIN_MS,
+  REQUEST_TIMEOUT_MIN_SECONDS,
+  REQUEST_TIMEOUT_MAX_SECONDS,
+  OAuth2TokenError,
+  MT5V2SignalRClient,
+  MT4V2SignalRError,
+  MT4V2SignalRClient,
+  ClientCredentialsTokenProvider,
+  CPluginWebApiClient,
+  ApiError
+};