@mywebapi.com/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CPlugin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,252 @@
+# @mywebapi.com/sdk
+
+TypeScript client for the SaaS WebAPI v2 (MT4/MT5 trading platform management).
+
+**Status:** Develop-only (not yet published). API shape is stable; package will be released to the private npm registry once the v2 API reaches production maturity.
+
+- **Auto-generated types** from the live OpenAPI spec — all endpoints, DTOs, and enums are exact and stay in sync with the server.
+- **Unified entry point** — `CPluginWebApiClient` with `mt4` and `mt5` namespaces; credentials and token management configured once at instantiation.
+- **Envelope-aware** — automatic unwrapping of API responses; failures throw `ApiError` carrying `code`, `description`, and `activityId`.
+- **Pagination helper** — `paged()` and `collectAll()` for cursor-based v2 list endpoints.
+- **Native fetch foundation** — uses platform `fetch` (Web API / Node.js 18+), injectable for testing.
+
+## Install
+
+```bash
+bun add @mywebapi.com/sdk
+# or: npm / pnpm install @mywebapi.com/sdk
+```
+
+**Credentials & trade platforms:** Create API keys (client ID and client secret) and manage your trade platforms in the CPlugin Toolbox — staging: https://pre.toolbox.cplugin.com · production: https://toolbox.cplugin.com
+
+## Quick start
+
+The SDK manages OAuth2 access tokens for you — pass `clientId` / `clientSecret` and the SDK handles discovery, caching, expiry, and 401-driven refresh transparently. Credentials and environment are configured once; then call methods on `client.mt4` or `client.mt5` namespaces.
+
+```typescript
+import { CPluginWebApiClient, ApiError, collectAll } from '@mywebapi.com/sdk';
+
+const client = new CPluginWebApiClient({
+  env: 'prod',  // or 'staging' or { baseUrl, authUrl }
+  clientId: 'your-client-id',
+  clientSecret: process.env.CPLUGIN_WEBAPI_CLIENT_SECRET!,
+});
+
+// MT4 server time
+const tp = '3029d415-d0a6-4710-a9c1-8cb063ef872f';
+const time = await client.mt4.getServerTime(tp);
+console.log('MT4 server time:', time.data.timestamp);
+
+// MT5 server time
+const mt5Time = await client.mt5.getServerTime(tp);
+console.log('MT5 server time:', mt5Time.data.timestamp);
+
+// Pagination — single page with cursor capture
+const page = await client.paged(() =>
+  client.mt4.getOnlineGet(tp, { limit: 50 }),
+);
+console.log(`Page items: ${page.items.length}, has more: ${page.paging?.hasMore}`);
+
+// Collect all items across pages
+const allUsers = await collectAll((cursor) =>
+  client.paged(() =>
+    client.mt4.getUsersRequest(tp, { limit: 100, ...(cursor ? { cursor } : {}) }),
+  ),
+);
+console.log(`Fetched ${allUsers.length} users across all pages`);
+
+// Async iteration over pages
+import { paginate } from '@mywebapi.com/sdk';
+for await (const pageItems of paginate((cursor) =>
+  client.paged(() =>
+    client.mt4.getUsersRequest(tp, { limit: 50, ...(cursor ? { cursor } : {}) }),
+  ),
+)) {
+  for (const user of pageItems) {
+    console.log(user.login, user.balance);
+  }
+}
+
+// Error handling
+try {
+  await client.mt4.getUserRecordGetLogin(tp, 99999999);
+} catch (e) {
+  if (e instanceof ApiError) {
+    console.error('API error:', {
+      code: e.code,
+      description: e.description,
+      activityId: e.activityId,
+    });
+  }
+}
+```
+
+### From environment variables
+
+`CPluginWebApiClient.fromEnvironment()` builds a client from `CPLUGIN_WEBAPI_ENV` (or `CPLUGIN_WEBAPI_BASE_URL` + `CPLUGIN_WEBAPI_AUTH_URL`), `CPLUGIN_WEBAPI_CLIENT_ID`, and `CPLUGIN_WEBAPI_CLIENT_SECRET`. Missing variables raise an `Error` that names the missing key.
+
+```typescript
+const client = CPluginWebApiClient.fromEnvironment();
+const tp = process.env.CPLUGIN_WEBAPI_TRADE_PLATFORM!;
+const time = await client.mt4.getServerTime(tp);
+```
+
+### Static token (advanced / testing)
+
+For scenarios with a pre-issued JWT (CI fixtures, short-lived service-account tokens, test rigs), pass a `token` instead of `clientId` / `clientSecret`. No refresh is performed — when the token expires, the API returns errors.
+
+```typescript
+const client = new CPluginWebApiClient({
+  env: 'prod',
+  token: 'eyJhbGc...',
+});
+
+const tp = '3029d415-d0a6-4710-a9c1-8cb063ef872f';
+const time = await client.mt4.getServerTime(tp);
+```
+
+## Retries
+
+Idempotent requests retry automatically on transient errors (`429`, `502`, `503`, `504`, and `408`). Retry-eligible:
+
+- `GET` and `HEAD` — always idempotent per HTTP spec.
+- `POST` / `PATCH` / `PUT` / `DELETE` — only when you supply an `Idempotency-Key` header via method options.
+
+Backoff is exponential (default 3 attempts, base 500 ms, factor 2, ±25% jitter) with `Retry-After` honoured (both `delta-seconds` and HTTP-date forms). Override per-client:
+
+```typescript
+const client = new CPluginWebApiClient({
+  env: 'prod',
+  clientId: '...',
+  clientSecret: '...',
+  retry: { maxAttempts: 5, baseDelayMs: 200 },
+});
+```
+
+## Error handling
+
+`ApiError` is thrown for any API-level failure. It carries `code`, `description`, and `activityId` for diagnostics and correlation.
+
+```typescript
+import { ApiError } from '@mywebapi.com/sdk';
+
+const tp = '3029d415-d0a6-4710-a9c1-8cb063ef872f';
+
+try {
+  await client.mt4.getUserRecordGetLogin(tp, 99999999);
+} catch (e) {
+  if (e instanceof ApiError) {
+    console.error('API error:', {
+      code: e.code,
+      description: e.description,
+      activityId: e.activityId,
+    });
+  } else {
+    console.error('Network or auth error:', e instanceof Error ? e.message : e);
+  }
+}
+```
+
+## Idempotency
+
+Mutating endpoints (POST / PATCH / PUT / DELETE) accept an optional `Idempotency-Key` header for safe retries. Pass it in the options object:
+
+```typescript
+const tp = '3029d415-d0a6-4710-a9c1-8cb063ef872f';
+
+await client.mt4.patchUserRecordLogin(
+  tp,
+  817542,
+  { comment: 'updated comment' },
+  { 'idempotency-key': 'my-request-id-12345' },
+);
+```
+
+Any string ≤255 chars is valid. Two calls with the same key within the server's `cacheTimeout` window return the cached response. Supplying a key also marks the request as idempotent for the retry layer, enabling automatic retry on transient failures.
+
+## Pagination helpers
+
+The SDK exports `paged()`, `paginate()`, and `collectAll()` helpers for paginated endpoints.
+
+**`client.paged(call)`** — wraps a single generated method call, capturing cursor metadata:
+
+```typescript
+const tp = '3029d415-d0a6-4710-a9c1-8cb063ef872f';
+
+const page = await client.paged(() =>
+  client.mt4.getTradesGet(tp, { limit: 50 }),
+);
+console.log(page.items, page.paging?.nextCursor, page.paging?.hasMore);
+```
+
+**`collectAll(fetchPage)`** — flattens all pages into a single array (requires `paged()` wrapper):
+
+```typescript
+const allTrades = await collectAll((cursor) =>
+  client.paged(() =>
+    client.mt4.getTradesGet(tp, { limit: 100, ...(cursor ? { cursor } : {}) }),
+  ),
+);
+console.log(`Total trades: ${allTrades.length}`);
+```
+
+**`paginate(fetchPage)`** — async iterable for streaming large datasets page-by-page:
+
+```typescript
+import { paginate } from '@mywebapi.com/sdk';
+
+for await (const pageItems of paginate((cursor) =>
+  client.paged(() =>
+    client.mt4.getTradesGet(tp, { limit: 100, ...(cursor ? { cursor } : {}) }),
+  ),
+)) {
+  // process pageItems without loading everything into memory
+}
+```
+
+## Development
+
+```bash
+bun install
+bun run fetch-spec    # download swagger.json from running WebAPI (WEBAPI_BASE_URL env)
+bun run generate      # regenerate src/generated/api.d.ts
+bun run typecheck
+
+# Integration tests against the live WebAPI — needs env vars (or a .env file):
+#   WEBAPI_BASE_URL, WEBAPI_AUTH_SERVER, WEBAPI_CLIENT_ID, WEBAPI_CLIENT_SECRET,
+#   WEBAPI_TRADE_PLATFORM, WEBAPI_KNOWN_LOGIN
+bun run test
+
+bun run build         # outputs dist/index.js + dist/*.d.ts
+```
+
+## SignalR (real-time streams)
+
+Real-time streaming is **built into this package** — there is no separate SignalR package. The only extra is the optional peer dependency `@microsoft/signalr`, installed **only if you use real-time** (the REST surface works without it):
+
+```sh
+bun add @microsoft/signalr   # or: npm install @microsoft/signalr
+```
+
+Open a hub from the same client — it reuses the client's environment and OAuth token:
+
+```ts
+const rt = client.realtime.mt4(tradePlatform);   // or client.realtime.mt5(tradePlatform)
+rt.onConnectionStatus((s) => console.log('connected:', s.connected));
+await rt.start();
+for await (const tick of rt.streamTicks('EURUSD')) {
+  console.log(tick.symbol, tick.bid, tick.ask);
+}
+await rt.stop();
+```
+
+MT4 hubs expose ticks, trades, margin-call, user and symbol streams; MT5 hubs expose connection status and margin-call updates.
+
+## What's next
+
+- Add typed convenience wrappers for every v2 endpoint as usage patterns crystallise.
+- Tag a release (`vX.Y.Z`) to publish `@mywebapi.com/sdk` to npm via the GitHub Actions workflow.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/auth.d.ts

@@ -0,0 +1,54 @@
+export interface TokenProvider {
+    /** Return a valid bearer token. May trigger a network call on first use or after expiry. */
+    getToken(opts?: {
+        forceRefresh?: boolean;
+    }): Promise<string>;
+}
+export declare class StaticTokenProvider implements TokenProvider {
+    private readonly token;
+    constructor(token: string);
+    getToken(_opts?: {
+        forceRefresh?: boolean;
+    }): Promise<string>;
+}
+export interface ClientCredentialsOptions {
+    clientId: string;
+    clientSecret: string;
+    /** IdentityServer base URL, e.g. `https://identity.example`. Discovery doc resolved as `${identityUrl}/.well-known/openid-configuration`. */
+    identityUrl: string;
+    scopes?: readonly string[];
+    /** Inject a custom fetch (tests, instrumentation). Defaults to global `fetch`. */
+    fetch?: typeof fetch;
+    /** Treat a token as expired this many seconds before its true expiry. RFC 6749 §10.4 — buffer for clock drift + flight time. */
+    clockSkewSeconds?: number;
+}
+export declare class OAuth2TokenError extends Error {
+    readonly status: number;
+    readonly errorCode: string | undefined;
+    readonly errorDescription: string | undefined;
+    readonly requestId: string | undefined;
+    constructor(opts: {
+        status: number;
+        errorCode?: string;
+        errorDescription?: string;
+        requestId?: string;
+    });
+}
+export declare class ClientCredentialsTokenProvider implements TokenProvider {
+    private readonly clientId;
+    private readonly clientSecret;
+    private readonly identityUrl;
+    private readonly scopes;
+    private readonly fetchFn;
+    private readonly clockSkewMs;
+    private cached;
+    private discoveryPromise;
+    private refreshPromise;
+    constructor(opts: ClientCredentialsOptions);
+    getToken(opts?: {
+        forceRefresh?: boolean;
+    }): Promise<string>;
+    private acquireToken;
+    private getDiscovery;
+    private fetchDiscovery;
+}

package/dist/client.d.ts

@@ -0,0 +1,137 @@
+import { MT4V2SignalRClient, type SignalRClientExtras } from './signalr';
+import { MT5V2SignalRClient } from './signalr.mt5';
+import type { RetryPolicy } from './retry';
+import { type EnvironmentSelector } from './environments';
+import { type UnwrapEnvelope } from './mutator';
+import type { PagedResult } from './pagination';
+/** A trade platform the authenticated principal can access.
+ *
+ *  Shape mirrors the server `TradePlatform` entity (serialized camelCase by STJ).
+ *  Known fields confirmed against a live server response (2026-06-26).
+ *  The index signature absorbs extra fields so client code does not break
+ *  if the server adds properties in future versions. */
+export interface TradePlatform {
+    /** Platform GUID — pass as `tradePlatform` to every MT4/MT5 endpoint. */
+    id: string;
+    /** Human-readable display name (e.g. "Demo MT4 London"). */
+    name?: string | null;
+    type?: string | number | null;
+    /** Manager login used for this platform connection. */
+    login?: number | null;
+    /** Organization (tenant) GUID this platform belongs to. */
+    organizationId?: string | null;
+    /** Nested organization object — id + name + created timestamp. */
+    organization?: {
+        id: string;
+        name: string;
+        created: string;
+    } | null;
+    /** ISO 8601 creation timestamp of this platform record. */
+    created?: string | null;
+    [key: string]: unknown;
+}
+import * as mt4Authentication from './generated/mt4-v2-authentication';
+import * as mt4BackupDestructive from './generated/mt4-v2-backup-destructive';
+import * as mt4Backup from './generated/mt4-v2-backup';
+import * as mt4Common from './generated/mt4-v2-common';
+import * as mt4Config from './generated/mt4-v2-config';
+import * as mt4Groups from './generated/mt4-v2-groups';
+import * as mt4History from './generated/mt4-v2-history';
+import * as mt4Mail from './generated/mt4-v2-mail';
+import * as mt4Margins from './generated/mt4-v2-margins';
+import * as mt4News from './generated/mt4-v2-news';
+import * as mt4Online from './generated/mt4-v2-online';
+import * as mt4Plugins from './generated/mt4-v2-plugins';
+import * as mt4Prices from './generated/mt4-v2-prices';
+import * as mt4Reports from './generated/mt4-v2-reports';
+import * as mt4ServerAdminDestructive from './generated/mt4-v2-server-admin-destructive';
+import * as mt4ServerAdmin from './generated/mt4-v2-server-admin';
+import * as mt4Symbols from './generated/mt4-v2-symbols';
+import * as mt4Trades from './generated/mt4-v2-trades';
+import * as mt4Users from './generated/mt4-v2-users';
+import * as mt4SidecarMessaging from './generated/mt4-v2-sidecar-messaging';
+import * as mt4SidecarPlugins from './generated/mt4-v2-sidecar-plugins';
+import * as mt4SidecarBatchReads from './generated/mt4-v2-sidecar-batch-reads';
+import * as mt4SidecarExternalCommand from './generated/mt4-v2-sidecar-externalcommand';
+import * as mt5Common from './generated/mt5-v2-common';
+import * as mt5Groups from './generated/mt5-v2-groups';
+import * as mt5Managers from './generated/mt5-v2-managers';
+import * as mt5Symbols from './generated/mt5-v2-symbols';
+import * as mt5Trades from './generated/mt5-v2-trades';
+import * as mt5Users from './generated/mt5-v2-users';
+export type MT4V2ClientOptions = {
+    baseUrl: string;
+    tradePlatform: string;
+    token: string;
+    fetch?: typeof fetch;
+    retry?: Partial<RetryPolicy>;
+} | {
+    baseUrl: string;
+    tradePlatform: string;
+    clientId: string;
+    clientSecret: string;
+    identityUrl: string;
+    scopes?: readonly string[];
+    fetch?: typeof fetch;
+    retry?: Partial<RetryPolicy>;
+};
+export interface CPluginWebApiClientOptions {
+    clientId: string;
+    clientSecret: string;
+    scopes?: readonly string[];
+    /** Inject a custom fetch implementation (testing / Bun / Node polyfill). */
+    fetch?: typeof fetch;
+    /** Override individual retry-policy fields. */
+    retry?: Partial<RetryPolicy>;
+}
+/** Combine environment selector with client credentials. */
+export type CPluginWebApiClientInit = EnvironmentSelector & CPluginWebApiClientOptions;
+type StripPlatform<K, P extends string> = K extends `${infer Base}${P}` ? Base : K;
+type CleanNamespace<M, P extends string> = {
+    [K in keyof M as StripPlatform<K & string, P>]: M[K];
+};
+type MT4Namespace = CleanNamespace<BoundModule<typeof mt4Authentication> & BoundModule<typeof mt4BackupDestructive> & BoundModule<typeof mt4Backup> & BoundModule<typeof mt4Common> & BoundModule<typeof mt4Config> & BoundModule<typeof mt4Groups> & BoundModule<typeof mt4History> & BoundModule<typeof mt4Mail> & BoundModule<typeof mt4Margins> & BoundModule<typeof mt4News> & BoundModule<typeof mt4Online> & BoundModule<typeof mt4Plugins> & BoundModule<typeof mt4Prices> & BoundModule<typeof mt4Reports> & BoundModule<typeof mt4ServerAdminDestructive> & BoundModule<typeof mt4ServerAdmin> & BoundModule<typeof mt4Symbols> & BoundModule<typeof mt4Trades> & BoundModule<typeof mt4Users> & BoundModule<typeof mt4SidecarMessaging> & BoundModule<typeof mt4SidecarPlugins> & BoundModule<typeof mt4SidecarBatchReads> & BoundModule<typeof mt4SidecarExternalCommand>, 'MT4'>;
+type MT5Namespace = CleanNamespace<BoundModule<typeof mt5Common> & BoundModule<typeof mt5Groups> & BoundModule<typeof mt5Managers> & BoundModule<typeof mt5Symbols> & BoundModule<typeof mt5Trades> & BoundModule<typeof mt5Users>, 'MT5'>;
+type BoundModule<M> = {
+    [K in keyof M]: M[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => Promise<UnwrapEnvelope<UnwrapEnvelope<R>>> : M[K];
+};
+/**
+ * Unified entry point for the CPlugin SaaS WebAPI v2 — MT4 and MT5 trading platform management.
+ *
+ * Client credentials (ID and secret) and trade platform configuration are managed in the CPlugin Toolbox
+ * (staging: https://pre.toolbox.cplugin.com, production: https://toolbox.cplugin.com).
+ * Once configured, access all MT4 and MT5 endpoints via the `mt4` and `mt5` namespaces and discover
+ * available platforms via `listTradePlatforms()`. Token management (OAuth2 client credentials flow) is
+ * handled automatically.
+ */
+export declare class CPluginWebApiClient {
+    /** All MT4 v2 endpoint functions, pre-wired to this client's context. */
+    readonly mt4: MT4Namespace;
+    /** All MT5 v2 endpoint functions, pre-wired to this client's context. */
+    readonly mt5: MT5Namespace;
+    readonly realtime: {
+        /** Create an `MT4V2SignalRClient` for the given trade platform, wired to this
+         *  client's shared token provider and base URL. Call `start()` on the result
+         *  to open the WebSocket connection. */
+        mt4(tradePlatform: string, extras?: SignalRClientExtras): MT4V2SignalRClient;
+        /** Create an `MT5V2SignalRClient` for the given trade platform, wired to this
+         *  client's shared token provider and base URL. Call `start()` on the result
+         *  to open the WebSocket connection. */
+        mt5(tradePlatform: string, extras?: SignalRClientExtras): MT5V2SignalRClient;
+    };
+    private readonly base;
+    constructor(init: CPluginWebApiClientInit);
+    paged<T>(call: () => Promise<T[]>): Promise<PagedResult<T>>;
+    /**
+     * Discover trade platforms available to the authenticated principal.
+     *
+     * Trade platforms are managed in the CPlugin Toolbox (staging: https://pre.toolbox.cplugin.com,
+     * production: https://toolbox.cplugin.com). Use the returned platform `id` values as the
+     * `tradePlatform` parameter for all MT4 and MT5 endpoint calls.
+     *
+     * @returns Array of trade platforms the authenticated user can access.
+     * @throws ApiError if authentication fails or the API request returns an error.
+     */
+    listTradePlatforms(): Promise<TradePlatform[]>;
+}
+export {};

package/dist/environments.d.ts

@@ -0,0 +1,13 @@
+export type EnvironmentName = 'prod' | 'staging' | 'custom';
+export interface ResolvedEnvironment {
+    apiBaseUrl: string;
+    authority: string;
+}
+export type EnvironmentSelector = {
+    env: 'prod' | 'staging';
+} | {
+    env: 'custom';
+    apiBaseUrl: string;
+    authority: string;
+};
+export declare function resolveEnvironment(sel: EnvironmentSelector): ResolvedEnvironment;

package/dist/errors.d.ts

@@ -0,0 +1,27 @@
+export type WebApiErrorCode = 'Ok' | 'NoConnect' | 'Validation' | 'MT4Error' | 'Forbidden' | 'NotFound' | 'MT5Error' | 'Internal';
+export interface PagingMeta {
+    nextCursor?: string | null;
+    hasMore: boolean;
+}
+export interface ApiMeta {
+    activityId?: string | null;
+    paging?: PagingMeta | null;
+}
+export interface ApiErrorBody {
+    code: WebApiErrorCode;
+    managerCode?: string | number | null;
+    message?: string | null;
+}
+export interface ApiEnvelope<T> {
+    data?: T | null;
+    error?: ApiErrorBody | null;
+    meta?: ApiMeta | null;
+}
+export declare class ApiError extends Error {
+    readonly code: WebApiErrorCode;
+    readonly description: string | undefined;
+    readonly activityId: string | undefined;
+    readonly managerCode: string | number | undefined;
+    readonly status: number;
+    constructor(body: ApiErrorBody, meta: ApiMeta | null | undefined, status: number);
+}

package/dist/generated/model/activationModes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generated by orval v8.19.0 🍺
+ * Do not edit manually.
+ * JSON-Pure WebAPI for MT4/MT5
+ * It uses native MetaQuote ManagerAPI for both MT4 and MT5 connection. Plus, it keep pumping connection active, so all *Get calls will run much faster, than *Request.<br/>Here partially used the idea of JSON-Pure API, only HTTP code 200 is acceptable. Other codes signal about errors on server side, which are out of control of client, like wrong parameters, platform unavailability, etc.
+ * OpenAPI spec version: 2.0
+ */
+export type ActivationModes = typeof ActivationModes[keyof typeof ActivationModes];
+export declare const ActivationModes: {
+    readonly None: "None";
+    readonly SL: "SL";
+    readonly TP: "TP";
+    readonly StopOut: "StopOut";
+};

package/dist/generated/model/activationType.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generated by orval v8.19.0 🍺
+ * Do not edit manually.
+ * JSON-Pure WebAPI for MT4/MT5
+ * It uses native MetaQuote ManagerAPI for both MT4 and MT5 connection. Plus, it keep pumping connection active, so all *Get calls will run much faster, than *Request.<br/>Here partially used the idea of JSON-Pure API, only HTTP code 200 is acceptable. Other codes signal about errors on server side, which are out of control of client, like wrong parameters, platform unavailability, etc.
+ * OpenAPI spec version: 2.0
+ */
+export type ActivationType = typeof ActivationType[keyof typeof ActivationType];
+export declare const ActivationType: {
+    readonly None: "None";
+    readonly SL: "SL";
+    readonly TP: "TP";
+    readonly Pending: "Pending";
+    readonly Stopout: "Stopout";
+    readonly StopOutRollback: "StopOutRollback";
+    readonly PendingRollback: "PendingRollback";
+    readonly TPRollback: "TPRollback";
+    readonly SLRollback: "SLRollback";
+};

package/dist/generated/model/apiError.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Generated by orval v8.19.0 🍺
+ * Do not edit manually.
+ * JSON-Pure WebAPI for MT4/MT5
+ * It uses native MetaQuote ManagerAPI for both MT4 and MT5 connection. Plus, it keep pumping connection active, so all *Get calls will run much faster, than *Request.<br/>Here partially used the idea of JSON-Pure API, only HTTP code 200 is acceptable. Other codes signal about errors on server side, which are out of control of client, like wrong parameters, platform unavailability, etc.
+ * OpenAPI spec version: 2.0
+ */
+import type { ResultCode } from './resultCode';
+import type { WebApiErrorCode } from './webApiErrorCode';
+/**
+ * v2 error body. Code is the stable transport error code; ManagerCode is the raw MT4
+ * ResultCode (serialized as a string for a known enum member, or as a number for an
+ * unrecognised value returned by MT4); Message is a human-readable description.
+ */
+export interface ApiError {
+    /** Stable transport-level error code. */
+    code?: WebApiErrorCode;
+    /** Raw MT4/MT5 manager result code, when the error came from the trading platform; otherwise null. */
+    managerCode?: ResultCode | null;
+    /**
+       * Human-readable error description.
+       * @nullable
+       */
+    message?: string | null;
+}

package/dist/generated/model/apiMeta.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generated by orval v8.19.0 🍺
+ * Do not edit manually.
+ * JSON-Pure WebAPI for MT4/MT5
+ * It uses native MetaQuote ManagerAPI for both MT4 and MT5 connection. Plus, it keep pumping connection active, so all *Get calls will run much faster, than *Request.<br/>Here partially used the idea of JSON-Pure API, only HTTP code 200 is acceptable. Other codes signal about errors on server side, which are out of control of client, like wrong parameters, platform unavailability, etc.
+ * OpenAPI spec version: 2.0
+ */
+import type { PagingMeta } from './pagingMeta';
+/**
+ * Response metadata. ActivityId is the W3C trace-id for correlation in Seq/SigNoz.
+ * Paging is present only on paginated list responses; otherwise it is omitted —
+ * the global JSON context policy serialises null fields, so we override that here
+ * with System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull.
+ */
+export interface ApiMeta {
+    /**
+       * W3C trace id for correlating this response in logs and tracing (Seq/SigNoz).
+       * @nullable
+       */
+    activityId?: string | null;
+    /** Pagination info; present only on list responses, omitted otherwise. */
+    paging?: PagingMeta | null;
+}

package/dist/generated/model/arcBackupExecutionPeriod.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generated by orval v8.19.0 🍺
+ * Do not edit manually.
+ * JSON-Pure WebAPI for MT4/MT5
+ * It uses native MetaQuote ManagerAPI for both MT4 and MT5 connection. Plus, it keep pumping connection active, so all *Get calls will run much faster, than *Request.<br/>Here partially used the idea of JSON-Pure API, only HTTP code 200 is acceptable. Other codes signal about errors on server side, which are out of control of client, like wrong parameters, platform unavailability, etc.
+ * OpenAPI spec version: 2.0
+ */
+export type ArcBackupExecutionPeriod = typeof ArcBackupExecutionPeriod[keyof typeof ArcBackupExecutionPeriod];
+export declare const ArcBackupExecutionPeriod: {
+    readonly M5: "M5";
+    readonly M15: "M15";
+    readonly M30: "M30";
+    readonly H1: "H1";
+};

package/dist/generated/model/arcBackupStorePeriod.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generated by orval v8.19.0 🍺
+ * Do not edit manually.
+ * JSON-Pure WebAPI for MT4/MT5
+ * It uses native MetaQuote ManagerAPI for both MT4 and MT5 connection. Plus, it keep pumping connection active, so all *Get calls will run much faster, than *Request.<br/>Here partially used the idea of JSON-Pure API, only HTTP code 200 is acceptable. Other codes signal about errors on server side, which are out of control of client, like wrong parameters, platform unavailability, etc.
+ * OpenAPI spec version: 2.0
+ */
+export type ArcBackupStorePeriod = typeof ArcBackupStorePeriod[keyof typeof ArcBackupStorePeriod];
+export declare const ArcBackupStorePeriod: {
+    readonly W1: "W1";
+    readonly W2: "W2";
+    readonly Mn1: "Mn1";
+    readonly Mn3: "Mn3";
+    readonly Mn6: "Mn6";
+};

package/dist/generated/model/backupExecutionPeriod.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generated by orval v8.19.0 🍺
+ * Do not edit manually.
+ * JSON-Pure WebAPI for MT4/MT5
+ * It uses native MetaQuote ManagerAPI for both MT4 and MT5 connection. Plus, it keep pumping connection active, so all *Get calls will run much faster, than *Request.<br/>Here partially used the idea of JSON-Pure API, only HTTP code 200 is acceptable. Other codes signal about errors on server side, which are out of control of client, like wrong parameters, platform unavailability, etc.
+ * OpenAPI spec version: 2.0
+ */
+export type BackupExecutionPeriod = typeof BackupExecutionPeriod[keyof typeof BackupExecutionPeriod];
+export declare const BackupExecutionPeriod: {
+    readonly H1: "H1";
+    readonly H4: "H4";
+    readonly D1: "D1";
+};

package/dist/generated/model/backupStorePeriod.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generated by orval v8.19.0 🍺
+ * Do not edit manually.
+ * JSON-Pure WebAPI for MT4/MT5
+ * It uses native MetaQuote ManagerAPI for both MT4 and MT5 connection. Plus, it keep pumping connection active, so all *Get calls will run much faster, than *Request.<br/>Here partially used the idea of JSON-Pure API, only HTTP code 200 is acceptable. Other codes signal about errors on server side, which are out of control of client, like wrong parameters, platform unavailability, etc.
+ * OpenAPI spec version: 2.0
+ */
+export type BackupStorePeriod = typeof BackupStorePeriod[keyof typeof BackupStorePeriod];
+export declare const BackupStorePeriod: {
+    readonly Mn1: "Mn1";
+    readonly Mn3: "Mn3";
+    readonly Mn6: "Mn6";
+    readonly Y1: "Y1";
+};