@qtsurfer/api-client 0.18.0 → 0.20.0

package/dist/index.d.ts

@@ -112,12 +112,34 @@ type Account = {
      * Your current subscription tier.
      */
     tier: string;
+    /**
+     * Maximum number of strategy executions (and sweeps) you can have running at the same time
+     * through the API. Starting one past this number is answered with `429`, whose message
+     * carries the same number. The value already includes any API allowance your plan has.
+     *
+     */
+    maxExecute: number;
+    /**
+     * Maximum length, in days, of the time range of a backtest on one of your own datasets.
+     */
+    maxRangeDays: number;
+    /**
+     * Largest full grid, in parameter combinations, a sweep may run with the `grid` sampler.
+     * A grid with more combinations is refused with `400`; the `random` and `lhs` samplers run
+     * only their `samples` and are not held to it.
+     *
+     */
+    maxSweepCartesian: number;
+    /**
+     * Maximum length, in hours, of the time range of one dataset import from an exchange.
+     */
+    maxImportRangeHours: number;
     /**
      * Maximum number of active datasets your tier allows.
      */
     maxDatasets: number;
     /**
-     * Maximum size, in bytes, of a single dataset version.
+     * Maximum size, in bytes, of a single dataset version as stored, that is the `bytes` of its ready version. For a CSV upload that is the converted file, not the file you upload, so estimate from the number of rows. The Datasets guide has the details.
      */
     maxDatasetBytes: number;
     /**
@@ -490,6 +512,11 @@ type SweepAxis = {
     values: Array<number | boolean>;
 };
 type SweepSpecRequest = {
+    /**
+     * `grid` runs every combination of the axes and is held to your plan's
+     * `maxSweepCartesian` (`GET /account`); `random` and `lhs` run `samples` combinations and are not.
+     *
+     */
     sampler?: "grid" | "random" | "lhs";
     /**
      * Reproducibility seed. If omitted, the server generates one with Java's
@@ -513,6 +540,9 @@ type SweepBaseConfig = {
     buyFeeRate?: number;
     sellFeeRate?: number;
     feeLeg?: "RECEIVED" | "QUOTE" | "BASE";
+    /**
+     * Share of the free balance each entry locks, in percent (0-100]. Omitted, a backtest sizes every entry with everything available.
+     */
     percentAmountToLock?: number;
 };
 type ExecuteSweepRequest = {
@@ -1155,6 +1185,12 @@ type StrategySummary = {
      *
      */
     requiredSources?: Array<string>;
+    /**
+     * When you deleted this strategy. Only ever present in `GET /strategies?includeDeleted=true`,
+     * and only on strategies you have deleted.
+     *
+     */
+    deletedAt?: string;
 };
 /**
  * What is known about a registered strategy: that it compiled, and what validating it found.
@@ -1266,6 +1302,12 @@ type Dataset = {
      *
      */
     currentVersionId?: string;
+    /**
+     * When you deleted this dataset. Only ever present in `GET /datasets?includeDeleted=true`,
+     * and only on datasets you have deleted.
+     *
+     */
+    deletedAt?: string;
     /**
      * When `currentVersionId` last changed. Absent until it has a value.
      */
@@ -1706,15 +1748,55 @@ type StartLiveRequest = {
         [key: string]: unknown;
     };
     /**
-     * A `public` run appears in `GET /live/public` and its signal channel accepts subscriptions from anyone, not only you.
+     * A `public` run appears in `GET /live/public` and its signal channel accepts subscriptions from anyone, not only you — from the moment it is promoted to `live`. While it is a `sandbox` trial, `public` is only what you asked for, and only you can read it.
      */
     visibility?: "private" | "public";
     /**
-     * Request that this run's signals be relayed over its WebSocket channel once it reaches the `live` stage — see the "Live execution" guide. Has no effect while the run is still in the `sandbox` stage, regardless of this value.
+     * Request that this run's signals be relayed over its WebSocket channel, from its first signal — in the `sandbox` stage too, where only you can subscribe to it. See the "Live execution" guide.
      */
     relay?: boolean;
     name?: string;
     description?: string;
+    paper?: LivePaperConfig;
+};
+/**
+ * Paper trading for this run: the same economics as a backtest's `baseConfig` (same fields,
+ * defaults and limits), plus `output`. An empty object takes every default. Each quote
+ * currency the run trades gets its own simulated account, opened with `initialFunding` in
+ * that currency; accounts are never added together. As returned on a run, the block is
+ * normalised: `feeRate` is resolved into `buyFeeRate`/`sellFeeRate` and defaults are filled
+ * in.
+ *
+ */
+type LivePaperConfig = {
+    /**
+     * Starting capital of each account, in that account's own quote currency.
+     */
+    initialFunding?: number;
+    /**
+     * Fee rate for both sides (0.001 = 0.1%). Accepted on start; returned resolved into the two fields below.
+     */
+    feeRate?: number;
+    /**
+     * Buy-side fee rate; overrides `feeRate`.
+     */
+    buyFeeRate?: number;
+    /**
+     * Sell-side fee rate; overrides `feeRate`.
+     */
+    sellFeeRate?: number;
+    /**
+     * Which asset fees are charged in. Case-insensitive on start.
+     */
+    feeLeg?: "RECEIVED" | "QUOTE" | "BASE";
+    /**
+     * Share of the account's free balance each entry locks, in percent. Omitted, the strategy's own setting applies, and without one 10%.
+     */
+    percentAmountToLock?: number;
+    /**
+     * `separate` keeps paper output out of the run's signals (read it with `GET /live/{runId}/paper`); `mix` also interleaves it into the run's signals as `type: paper`, right after the signal that caused it.
+     */
+    output?: "separate" | "mix";
 };
 type UpdateLiveRequest = {
     visibility?: "private" | "public";
@@ -1729,6 +1811,18 @@ type UpdateLiveParamsRequest = {
         [key: string]: unknown;
     };
 };
+type SendLiveCommandRequest = {
+    /**
+     * The command's text — non-blank.
+     */
+    command: string;
+    /**
+     * An optional map of your own choosing, alongside command. Absent means none; when given, it must be a JSON object, and `command` and `properties` are the only keys the body may carry. Each entry lands as a top-level entry on the strategy's `CommandRequest` — no key is off limits, since the command's own text is kept separately.
+     */
+    properties?: {
+        [key: string]: unknown;
+    };
+};
 /**
  * A live run's full state, as returned by starting, reading, or stopping it through its strategy.
  */
@@ -1742,11 +1836,11 @@ type LiveRun = {
     description?: string;
     visibility: "private" | "public";
     /**
-     * A new run always starts `SANDBOX` — a trial run compared against a second execution for agreement — and moves to `LIVE` once it passes.
+     * A new run always starts `SANDBOX`, a 24-hour trial in which it is compared against a second execution and checked for resource use and stability. A run that passes moves to `LIVE` automatically when the 24 hours are up.
      */
     stage: "SANDBOX" | "LIVE";
     /**
-     * `STARTING` until first observed running; otherwise the runner's own reported state (e.g. `RUNNING`).
+     * The run's health right now: `STARTING` (no runner has reported on it yet), `RUNNING`, `LAGGING` (behind the market data, usually while catching up; clears by itself), `HUNG` (stuck inside one strategy call for longer than allowed; clears when it returns), `DEGRADED` (its independent executions produced different signals), `FAILED` (refused, could not start or failed while running; `reason` says why) or `STOPPED`. `LAGGING`, `HUNG` and `DEGRADED` come and go on a running run. The set may grow: read an unknown value as a running run with something to look at. See the Live execution guide.
      */
     state: string;
     /**
@@ -1754,7 +1848,17 @@ type LiveRun = {
      */
     desired: "RUNNING" | "STOPPED";
     /**
-     * Present only when the run stopped because it exceeded its resource allowance.
+     * Why the run stopped or failed, when there is something to say; absent otherwise. It is never a
+     * stack trace or an internal message. Either `resource: ...` (the platform stopped the run for
+     * exceeding its resource allowance; the text says which limit) or one of a fixed set of sentences for
+     * a `FAILED` run: the strategy cannot consume the source type the run was started with, the run's
+     * definition was refused, the run could not start after several attempts, the strategy failed while
+     * processing data, the run lost its data feed, or the generic `The run failed.`. The set may grow:
+     * read an unrecognised sentence as a failure and do not parse it. A `FAILED` run usually stays
+     * `desired: RUNNING` until you stop it, and counts as active (`409` on a new start, and toward your
+     * live-run limit) until then; one that can never run because its strategy cannot consume its source
+     * type is stopped by the platform itself (`desired: STOPPED`), so it holds no place.
+     *
      */
     reason?: string;
     sources: Array<LiveSource>;
@@ -1766,7 +1870,7 @@ type LiveRun = {
      */
     paramsVersion: number;
     /**
-     * Whether this run's signals are being relayed over the WebSocket channel described in the "Live execution" guide, right now. This is the effective value — `false` on a `sandbox` run regardless of what was requested at start; matches the requested value once `stage` reaches `live`.
+     * Whether this run's signals are relayed over the WebSocket channel described in the "Live execution" guide. It is the value requested at start, in either stage.
      */
     relay: boolean;
     /**
@@ -1774,11 +1878,15 @@ type LiveRun = {
      */
     startedAtMs: number;
     /**
-     * The sandbox trial's promotion verdict, once one exists. Shape is not yet stabilized as public API — treat as opaque diagnostics.
+     * The sandbox trial's promotion verdict. Absent for the whole 24-hour trial and present once it ends, so an absent `gate` means the trial has not finished. `passed` is the verdict; the rest is diagnostic detail whose shape is not yet stabilized as public API: treat it as opaque.
      */
     gate?: {
         [key: string]: unknown;
     };
+    /**
+     * The run's paper trading configuration as accepted at start, normalised. Absent when the run has no paper trading.
+     */
+    paper?: LivePaperConfig;
 };
 /**
  * A run's state as returned by `PATCH /live/{runId}` — narrower than `LiveRun` (no `strategyId`, `params`, or `desired`), since this endpoint is addressed by `runId` alone.
@@ -1805,17 +1913,31 @@ type LiveRunSummary = {
     description?: string;
     visibility: "private" | "public";
     /**
-     * A new run always starts `SANDBOX` — a trial run compared against a second execution for agreement — and moves to `LIVE` once it passes.
+     * A new run always starts `SANDBOX`, a 24-hour trial in which it is compared against a second execution and checked for resource use and stability. A run that passes moves to `LIVE` automatically when the 24 hours are up.
      */
     stage: "SANDBOX" | "LIVE";
     /**
-     * `STARTING` until first observed running; otherwise the runner's own reported state (e.g. `RUNNING`).
+     * The run's health right now: `STARTING` (no runner has reported on it yet), `RUNNING`, `LAGGING` (behind the market data, usually while catching up; clears by itself), `HUNG` (stuck inside one strategy call for longer than allowed; clears when it returns), `DEGRADED` (its independent executions produced different signals), `FAILED` (refused, could not start or failed while running; `reason` says why) or `STOPPED`. `LAGGING`, `HUNG` and `DEGRADED` come and go on a running run. The set may grow: read an unknown value as a running run with something to look at. See the Live execution guide.
      */
     state: string;
     /**
      * What you last asked for. `state` can lag this briefly after `DELETE`.
      */
     desired: "RUNNING" | "STOPPED";
+    /**
+     * Why the run stopped or failed, when there is something to say; absent otherwise. It is never a
+     * stack trace or an internal message. Either `resource: ...` (the platform stopped the run for
+     * exceeding its resource allowance; the text says which limit) or one of a fixed set of sentences for
+     * a `FAILED` run: the strategy cannot consume the source type the run was started with, the run's
+     * definition was refused, the run could not start after several attempts, the strategy failed while
+     * processing data, the run lost its data feed, or the generic `The run failed.`. The set may grow:
+     * read an unrecognised sentence as a failure and do not parse it. A `FAILED` run usually stays
+     * `desired: RUNNING` until you stop it, and counts as active (`409` on a new start, and toward your
+     * live-run limit) until then; one that can never run because its strategy cannot consume its source
+     * type is stopped by the platform itself (`desired: STOPPED`), so it holds no place.
+     *
+     */
+    reason?: string;
     sources: Array<LiveSource>;
     /**
      * Epoch milliseconds this run was started.
@@ -1865,6 +1987,106 @@ type LiveSignalPage = {
     availableSinceMs?: number;
     _links?: PublicLiveListLinks;
 };
+type LivePaper = {
+    runId: string;
+    stage: "SANDBOX" | "LIVE";
+    accounts: Array<LivePaperAccount>;
+};
+/**
+ * One simulated account — one per quote currency the run trades.
+ */
+type LivePaperAccount = {
+    /**
+     * The account's quote currency; every amount below is in it.
+     */
+    currency: string;
+    initialFunding: number;
+    /**
+     * Latest recorded equity — see `equityKind`.
+     */
+    equity: number;
+    /**
+     * Market time of that value. Absent while the account holds its starting capital.
+     */
+    equityAtMs?: number;
+    /**
+     * `equity` at a closed trade, `mark` at a periodic mark-to-market (includes open positions at market price).
+     */
+    equityKind?: "equity" | "mark";
+    /**
+     * Sum of the PnL of the closed trades.
+     */
+    realisedPnl: number;
+    /**
+     * Closed trades.
+     */
+    trades: number;
+    /**
+     * Times open positions were lost because the run was restarted with them open.
+     */
+    gaps: number;
+    openPositions: Array<LivePaperPosition>;
+    kpi?: LivePaperKpi;
+};
+type LivePaperPosition = {
+    instrument: string;
+    /**
+     * Amount held, in the base asset.
+     */
+    base: number;
+    /**
+     * What it cost, in the account's currency.
+     */
+    cost: number;
+};
+/**
+ * The same KPIs a backtest reports, over the trades closed so far. Absent until the first closed trade is recorded.
+ */
+type LivePaperKpi = {
+    totalTrades?: number;
+    winCount?: number;
+    lossCount?: number;
+    /**
+     * Ratio (0.5 = half the trades won).
+     */
+    winRate?: number;
+    pnlTotal?: number;
+    /**
+     * Percent of `initialFunding` (0-100 scale).
+     */
+    pnlTotalPercent?: number;
+    sharpeRatio?: number | null;
+    sortinoRatio?: number | null;
+    /**
+     * Ratio (0.15 for 15%).
+     */
+    cagr?: number | null;
+    maxDrawdown?: number;
+    /**
+     * Percent (0-100 scale).
+     */
+    maxDrawdownPercent?: number;
+};
+type LivePaperEquityPage = {
+    points: Array<LivePaperEquityPoint>;
+    _links?: {
+        next?: {
+            href?: string;
+        };
+    };
+};
+type LivePaperEquityPoint = {
+    currency: string;
+    kind: "equity" | "mark" | "gap";
+    /**
+     * Market time of the point.
+     */
+    eventTsMs: number;
+    /**
+     * Absent on a `gap`.
+     */
+    equity?: number;
+};
 /**
  * One signal, in the same shape the real-time signal channel delivers.
  */
@@ -1886,9 +2108,12 @@ type LiveSignal = {
      * The parameter set in force when this signal was produced.
      */
     paramsVersion?: number;
-    type: "hint" | "info" | "marker" | "command";
     /**
-     * `BUY`/`SELL` for a `hint`, the command name for a `command`, absent otherwise.
+     * `paper` items appear only for a run whose `paper.output` is `mix`; they are not relayed over the WebSocket channel.
+     */
+    type: "hint" | "info" | "marker" | "command" | "paper";
+    /**
+     * `BUY`/`SELL` for a `hint`, the command name for a `command`; for `paper`, what the item is: `fill`, `trade`, `equity`, `mark`, `kpi` or `gap`. Absent otherwise.
      */
     kind?: string | null;
     /**
@@ -1899,10 +2124,13 @@ type LiveSignal = {
      * Time it was published — always at or after `eventTsMs`.
      */
     emittedAtMs: number;
-    instrument: LiveSignalInstrument;
+    /**
+     * The instrument the signal is about. `null` only for a `paper` item about a whole account (`equity`, `mark`, `kpi`), whose `data.currency` names the account.
+     */
+    instrument: LiveSignalInstrument | null;
     order?: LiveSignalOrder;
     /**
-     * The signal's own free-form payload.
+     * The signal's own free-form payload, what the strategy put there with `signal.set(...)`. Whoever may read the run may read it, so on a `public` run it is public. A signal whose `data` is over 8 KiB (8,192 bytes of its JSON) is not pushed on the WebSocket channel, and `GET /live/{runId}/signals` returns it whole.
      */
     data?: {
         [key: string]: unknown;
@@ -1949,6 +2177,17 @@ type LiveParamsUpdateResult = {
      */
     effectiveAtMs: number;
 };
+type LiveCommandResult = {
+    runId: string;
+    /**
+     * This command's own id, generated fresh for this call. A retried request is a second, distinct command — this endpoint takes no idempotency key.
+     */
+    commandId: string;
+    /**
+     * Epoch milliseconds — the market position every execution applies this command at.
+     */
+    effectiveAtMs: number;
+};
 type AuthenticateData = {
     body?: never;
     path?: never;
@@ -2185,7 +2424,14 @@ type DownloadKlinesResponse = DownloadKlinesResponses[keyof DownloadKlinesRespon
 type ListStrategiesData = {
     body?: never;
     path?: never;
-    query?: never;
+    query?: {
+        /**
+         * `true` also lists the strategies you have deleted, each with its `deletedAt`. Any other
+         * value, or leaving it out, lists only the ones you have not deleted.
+         *
+         */
+        includeDeleted?: boolean;
+    };
     url: "/strategies";
 };
 type ListStrategiesResponses = {
@@ -2215,6 +2461,10 @@ type CompileStrategyErrors = {
      *
      */
     400: ResponseError;
+    /**
+     * The source is larger than 32 KiB (32768 bytes). Every endpoint that reads a request body caps it, and the message names the cap; see the Strategy guide.
+     */
+    413: ResponseError;
     /**
      * Too many compilations in flight. Retry later.
      */
@@ -2466,7 +2716,9 @@ type ExecuteSweepData = {
 type ExecuteSweepErrors = {
     /**
      * Invalid sweep specification, a `type` that cannot be swept yet (`funding`), or the
-     * expanded grid exceeds the server limit.
+     * expanded grid exceeds the server limit. A full `grid` with more combinations than your
+     * plan allows (`maxSweepCartesian` in `GET /account`) is refused with a message that asks
+     * for the `random` or `lhs` sampler.
      *
      */
     400: ResponseError;
@@ -2808,7 +3060,14 @@ type GetBacktestResultResponse = GetBacktestResultResponses[keyof GetBacktestRes
 type ListDatasetsData = {
     body?: never;
     path?: never;
-    query?: never;
+    query?: {
+        /**
+         * `true` also lists the datasets you have deleted, each with its `deletedAt`. Any other
+         * value, or leaving it out, lists only the ones you have not deleted.
+         *
+         */
+        includeDeleted?: boolean;
+    };
     url: "/datasets";
 };
 type ListDatasetsResponses = {
@@ -2965,7 +3224,7 @@ type FinalizeDatasetUploadErrors = {
      */
     409: ResponseError;
     /**
-     * The uploaded file exceeds your tier's size limit for a dataset.
+     * The uploaded file is many times your tier's size limit for a dataset. The limit itself applies to the stored size, which is known only after conversion, so an upload that passes here can still end `failed` when ingest finishes.
      */
     413: ResponseError;
     /**
@@ -3151,7 +3410,7 @@ type StartLiveData = {
 };
 type StartLiveErrors = {
     /**
-     * Malformed `sources` (not exactly one entry, missing field, unsupported `type`), or an invalid `visibility`.
+     * Malformed `sources` (not exactly one entry, missing field, unsupported `type`), a `type` the strategy cannot consume (a ticker strategy with a `kline` source, or the reverse; the message names both), an invalid `visibility`, an invalid `paper` block (an unknown field, a wrong type or an out-of-range value), or no `paper` block for a strategy that listens to its own execution events.
      */
     400: ResponseError;
     /**
@@ -3283,7 +3542,7 @@ type UpdateLiveParamsErrors = {
      */
     404: ResponseError;
     /**
-     * This run's compilation has no declared properties on record — recompile the strategy to enable runtime parameter updates.
+     * This run's compiled strategy has no record of the parameters it declares. Register the strategy again with `POST /strategy` and start a new run, since a run keeps the compiled version it started with.
      */
     409: ResponseError;
 };
@@ -3295,6 +3554,48 @@ type UpdateLiveParamsResponses = {
     200: LiveParamsUpdateResult;
 };
 type UpdateLiveParamsResponse = UpdateLiveParamsResponses[keyof UpdateLiveParamsResponses];
+type SendLiveCommandData = {
+    body: SendLiveCommandRequest;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: "/live/{runId}/commands";
+};
+type SendLiveCommandErrors = {
+    /**
+     * `command` missing, not a string, blank; `properties` given but not an object; or the body carries any key other than `command` and `properties`.
+     */
+    400: ResponseError;
+    /**
+     * No such run, or you do not own it.
+     */
+    404: ResponseError;
+    /**
+     * One of three reasons, each its own message: the run is not running, so there is nothing to tell;
+     * this run's compiled strategy has no record of whether it handles commands — register the strategy
+     * again with `POST /strategy` and start a new run, since a run keeps the compiled version it started
+     * with; or the strategy does not implement `CommandRequestHandler` at all.
+     *
+     */
+    409: ResponseError;
+    /**
+     * The request body is larger than 2 KiB (2048 bytes). Every endpoint that reads a request body caps it, and the message names the cap.
+     */
+    413: ResponseError;
+    /**
+     * The command could not be delivered right now, and it was not sent — unlike a parameter update, a command has no fallback path. Try again.
+     */
+    503: ResponseError;
+};
+type SendLiveCommandError = SendLiveCommandErrors[keyof SendLiveCommandErrors];
+type SendLiveCommandResponses = {
+    /**
+     * Accepted — on its way to every execution behind the run.
+     */
+    202: LiveCommandResult;
+};
+type SendLiveCommandResponse = SendLiveCommandResponses[keyof SendLiveCommandResponses];
 type GetLiveRunSignalsData = {
     body?: never;
     path: {
@@ -3317,6 +3618,10 @@ type GetLiveRunSignalsData = {
          *
          */
         instrument?: string;
+        /**
+         * Narrow to one or more signal types, comma-separated (`hint`, `info`, `marker`, `command`, `paper`). Combines with `instrument`.
+         */
+        type?: string;
         /**
          * Continue from a previous page's `_links.next`. Takes precedence over `sinceMs`.
          */
@@ -3330,7 +3635,7 @@ type GetLiveRunSignalsData = {
 };
 type GetLiveRunSignalsErrors = {
     /**
-     * `instrument`, `sinceMs`, `limit` or `cursor` is malformed.
+     * `instrument`, `type`, `sinceMs`, `limit` or `cursor` is malformed.
      */
     400: ResponseError;
     /**
@@ -3350,6 +3655,68 @@ type GetLiveRunSignalsResponses = {
     200: LiveSignalPage;
 };
 type GetLiveRunSignalsResponse = GetLiveRunSignalsResponses[keyof GetLiveRunSignalsResponses];
+type GetLiveRunPaperData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: "/live/{runId}/paper";
+};
+type GetLiveRunPaperErrors = {
+    /**
+     * No such run, not one you may read, or a run without paper trading.
+     */
+    404: ResponseError;
+};
+type GetLiveRunPaperError = GetLiveRunPaperErrors[keyof GetLiveRunPaperErrors];
+type GetLiveRunPaperResponses = {
+    /**
+     * The run's paper accounts
+     */
+    200: LivePaper;
+};
+type GetLiveRunPaperResponse = GetLiveRunPaperResponses[keyof GetLiveRunPaperResponses];
+type GetLiveRunPaperEquityData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: {
+        /**
+         * One account's quote currency, e.g. `USDT`.
+         */
+        currency?: string;
+        /**
+         * Start from this market time (epoch ms). Ignored when `cursor` is given.
+         */
+        sinceMs?: number;
+        /**
+         * Continue from a previous page's `_links.next`.
+         */
+        cursor?: string;
+        limit?: number;
+    };
+    url: "/live/{runId}/paper/equity";
+};
+type GetLiveRunPaperEquityErrors = {
+    /**
+     * `sinceMs`, `limit` or `cursor` is malformed.
+     */
+    400: ResponseError;
+    /**
+     * No such run, not one you may read, or a run without paper trading.
+     */
+    404: ResponseError;
+};
+type GetLiveRunPaperEquityError = GetLiveRunPaperEquityErrors[keyof GetLiveRunPaperEquityErrors];
+type GetLiveRunPaperEquityResponses = {
+    /**
+     * One page of the curve
+     */
+    200: LivePaperEquityPage;
+};
+type GetLiveRunPaperEquityResponse = GetLiveRunPaperEquityResponses[keyof GetLiveRunPaperEquityResponses];
 type MintLiveConnectionTokenData = {
     body?: never;
     path?: never;
@@ -3488,6 +3855,10 @@ declare const downloadKlines: <ThrowOnError extends boolean = false>(options: Op
  * many strategies you have. Check a specific strategy's validation with `GET
  * /strategy/{strategyId}`.
  *
+ * With `includeDeleted=true`, strategies you have deleted are listed too, each with the
+ * `deletedAt` it was deleted at — useful to keep a copy of your list in sync, telling a
+ * deleted strategy apart from one that never existed.
+ *
  */
 declare const listStrategies: <ThrowOnError extends boolean = false>(options?: Options<ListStrategiesData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
     strategies: Array<StrategySummary>;
@@ -3509,6 +3880,11 @@ declare const listStrategies: <ThrowOnError extends boolean = false>(options?: O
  * included, is read from `GET /strategy/{strategyId}`. One place to ask, so there is no second
  * answer to keep in step.
  *
+ * A `200` means the source parsed and compiled, not that it will run. What only shows once the
+ * strategy sets up its indicators is found by `validate`: for QTScript, a window on an indicator
+ * name that is not registered (`window nosuch m1 { ... }`) registers, and `validate` ends `failed`
+ * on that line.
+ *
  * For **Java**, the `strategyId` is derived from what the code *means*, not from how it is
  * written. Adding a comment, inserting a blank line, re-indenting, reordering imports, or
  * moving a method around all return the **same** id — you have not created a second strategy.
@@ -3802,6 +4178,10 @@ declare const getBacktestResult: <ThrowOnError extends boolean = false>(options:
  * Every dataset you have created and not deleted, most recently created first. Never a `404`
  * — an empty array if you have none, same convention as `GET /strategies`.
  *
+ * With `includeDeleted=true`, datasets you have deleted are listed too, each with the
+ * `deletedAt` it was deleted at — useful to keep a copy of your list in sync, telling a
+ * deleted dataset apart from one that never existed.
+ *
  */
 declare const listDatasets: <ThrowOnError extends boolean = false>(options?: Options<ListDatasetsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
     datasets: Array<Dataset>;
@@ -3975,6 +4355,14 @@ declare const getLive: <ThrowOnError extends boolean = false>(options: Options<G
  * the "Live execution" guide linked from this tag's description for the full flow (minting a
  * connection token, the channel and RPC method).
  *
+ * **Paper trading.** Pass a `paper` block to have the run's hints executed in simulation from
+ * its first tick, as a backtest would execute them: fills, closed trades, equity and KPIs,
+ * with one simulated account per quote currency. Omitted, the run has no paper trading. It
+ * takes the same economics as a backtest's `baseConfig` plus where its output goes; read it
+ * back with `GET /live/{runId}/paper`. A strategy that listens to its own execution events
+ * (it overrides `getExecutionCallback()`) has no other execution venue, so it cannot start
+ * without a `paper` block.
+ *
  */
 declare const startLive: <ThrowOnError extends boolean = false>(options: Options<StartLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRun, ResponseError, ThrowOnError>;
 /**
@@ -3987,8 +4375,9 @@ declare const startLive: <ThrowOnError extends boolean = false>(options: Options
 declare const listLive: <ThrowOnError extends boolean = false>(options?: Options<ListLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveListResponse, ResponseError, ThrowOnError>;
 /**
  * Browse public live runs
- * Every run whose owner marked it `public` and is currently live and running — anyone's,
- * yours included, and listed without revealing who owns it. Most recently started first.
+ * Every run whose owner marked it `public`, that has been promoted to `live` and is running —
+ * anyone's, yours included, and listed without revealing who owns it. A `public` run still in
+ * its `sandbox` trial is not listed. Most recently started first.
  *
  * This is the only `Live Execution` endpoint that needs no `Authorization` header.
  *
@@ -4021,6 +4410,24 @@ declare const updateLive: <ThrowOnError extends boolean = false>(options: Option
  *
  */
 declare const updateLiveParams: <ThrowOnError extends boolean = false>(options: Options<UpdateLiveParamsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveParamsUpdateResult, ResponseError, ThrowOnError>;
+/**
+ * Tell a running strategy a command
+ * Tells a running strategy something **while it stays live**, without restarting it — for a strategy that
+ * implements the engine's `CommandRequestHandler`. Owner only.
+ *
+ * A command is an event, not a stored setting: it is delivered once to every execution behind the run, at
+ * the same market position, and nothing about it is written to the run's state. **It is transient** — a
+ * replica that restarts replays only its recent market history, so a command from before that only reaches
+ * one that was already running when it arrived. Anything the strategy needs to remember across a restart
+ * belongs in a parameter (`PUT /live/{runId}/params`), which does have a stored value; a command does not.
+ *
+ * The command's text is a plain string; an optional `properties` object of your own choosing travels
+ * alongside it. Each entry lands as a top-level entry on the `CommandRequest` the handler receives —
+ * `request.get("<key>")` in Java, `$command.<key>` sugar in QTScript — no key is off limits, since the
+ * command's own text is kept separately.
+ *
+ */
+declare const sendLiveCommand: <ThrowOnError extends boolean = false>(options: Options<SendLiveCommandData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveCommandResult, ResponseError, ThrowOnError>;
 /**
  * Read a run's signals
  * Returns one page of the signals a run has already produced, newest-last, optionally from a
@@ -4044,11 +4451,45 @@ declare const updateLiveParams: <ThrowOnError extends boolean = false>(options:
  * serving a shortened page that looks complete. Treat that as a normal outcome: read
  * `availableSinceMs` from the error and start again from there.
  *
- * Readable by the run's owner, and by anyone if the run is `public` — the same rule the
- * signal channel applies to a subscription.
+ * Readable by the run's owner, and by anyone if the run is `public` and has reached the `live`
+ * stage — the same rule the signal channel applies to a subscription. A `sandbox` run is read
+ * by its owner only, whatever visibility it asked for.
  *
  */
 declare const getLiveRunSignals: <ThrowOnError extends boolean = false>(options: Options<GetLiveRunSignalsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveSignalPage, ResponseError, ThrowOnError>;
+/**
+ * Read a run's paper trading
+ * The run's paper trading as last recorded: one entry per simulated account (one per quote
+ * currency the run trades — never added together), with its starting capital, current
+ * equity, realised PnL, open positions and KPIs. The KPIs are the same a backtest reports,
+ * computed over the trades closed so far.
+ *
+ * `equity` is the account's latest recorded value: at the last closed trade (`equityKind:
+ * equity`), or the last periodic mark-to-market while positions are open (`equityKind:
+ * mark`, taken every minute of market time). Until either exists the account holds its
+ * starting capital.
+ *
+ * Readable by the run's owner, and by anyone if the run is `public` and has reached the `live`
+ * stage. A run started without a `paper` block answers `404`.
+ *
+ */
+declare const getLiveRunPaper: <ThrowOnError extends boolean = false>(options: Options<GetLiveRunPaperData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LivePaper, ResponseError, ThrowOnError>;
+/**
+ * Read a run's paper equity curve
+ * The run's paper equity curve, oldest first, page by page. It is kept for the life of the
+ * run, so unlike signals it has no moving window. Points are `equity` at every closed trade,
+ * `mark` every minute of market time while positions are open, and `gap` where the run was
+ * restarted with positions open: those positions are not carried over, so the curve has no
+ * value there.
+ *
+ * `currency` narrows to one account; without it, every account's points come interleaved by
+ * time, each carrying its currency.
+ *
+ * Readable by the run's owner, and by anyone if the run is `public` and has reached the `live`
+ * stage.
+ *
+ */
+declare const getLiveRunPaperEquity: <ThrowOnError extends boolean = false>(options: Options<GetLiveRunPaperEquityData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LivePaperEquityPage, ResponseError, ThrowOnError>;
 /**
  * Mint a WebSocket connection token
  * Mints a short-lived token for the WebSocket connection used to receive a run's signals in
@@ -4061,4 +4502,4 @@ declare const mintLiveConnectionToken: <ThrowOnError extends boolean = false>(op
 
 declare const client: _hey_api_client_fetch.Client;
 
-export { type AcceptedJob, type Account, type AccountLinks, type AccountUsage, type AccountUsageLinks, type AuthTokenError, type AuthTokenResponse, type AuthenticateData, type AuthenticateError, type AuthenticateErrors, type AuthenticateResponse, type AuthenticateResponses, type BacktestJobResult, type CancelBacktestData, type CancelBacktestError, type CancelBacktestErrors, type CancelBacktestResponse, type CancelBacktestResponses, type CancelSweepData, type CancelSweepError, type CancelSweepErrors, type CancelSweepResponse, type CancelSweepResponses, type ClientOptions, type CompileStrategyData, type CompileStrategyError, type CompileStrategyErrors, type CompileStrategyResponse, type CompileStrategyResponses, type CoverageWindow, type CreateDatasetData, type CreateDatasetError, type CreateDatasetErrors, type CreateDatasetResponse, type CreateDatasetResponses, type DataSourceType, type Dataset, type DatasetCreated, type DatasetImportCreated, type DatasetImportDexRequest, type DatasetImportRequest, type DatasetImportState, type DatasetUploadSession, type DatasetUploadState, type DatasetUploadTarget, type DatasetVersion, type DatasetWithLinks, type DeclaredProperty, type DeleteDatasetData, type DeleteDatasetError, type DeleteDatasetErrors, type DeleteDatasetResponse, type DeleteDatasetResponses, type DeleteStrategyData, type DeleteStrategyError, type DeleteStrategyErrors, type DeleteStrategyResponse, type DeleteStrategyResponses, type DownloadKlinesData, type DownloadKlinesError, type DownloadKlinesErrors, type DownloadKlinesResponse, type DownloadKlinesResponses, type DownloadTickersData, type DownloadTickersError, type DownloadTickersErrors, type DownloadTickersResponse, type DownloadTickersResponses, type EquityCurveMeta, type EquityCurveOptions, type EquityCurveOutMode, type EquityCurveRequest, type EquityCurveResult, type EquityPoint, type Exchange, type ExecuteBacktestData, type ExecuteBacktestError, type ExecuteBacktestErrors, type ExecuteBacktestResponse, type ExecuteBacktestResponses, type ExecuteSweepAccepted, type ExecuteSweepData, type ExecuteSweepError, type ExecuteSweepErrors, type ExecuteSweepRequest, type ExecuteSweepResponse, type ExecuteSweepResponses, type ExecuteSweepResult, type FinalizeDatasetUploadData, type FinalizeDatasetUploadError, type FinalizeDatasetUploadErrors, type FinalizeDatasetUploadResponse, type FinalizeDatasetUploadResponses, type GetAccountData, type GetAccountResponse, type GetAccountResponses, type GetAccountUsageData, type GetAccountUsageResponse, type GetAccountUsageResponses, type GetBacktestResultData, type GetBacktestResultError, type GetBacktestResultErrors, type GetBacktestResultResponse, type GetBacktestResultResponses, type GetDatasetData, type GetDatasetError, type GetDatasetErrors, type GetDatasetImportData, type GetDatasetImportError, type GetDatasetImportErrors, type GetDatasetImportResponse, type GetDatasetImportResponses, type GetDatasetResponse, type GetDatasetResponses, type GetDatasetUploadData, type GetDatasetUploadError, type GetDatasetUploadErrors, type GetDatasetUploadResponse, type GetDatasetUploadResponses, type GetLiveData, type GetLiveError, type GetLiveErrors, type GetLiveResponse, type GetLiveResponses, type GetLiveRunSignalsData, type GetLiveRunSignalsError, type GetLiveRunSignalsErrors, type GetLiveRunSignalsResponse, type GetLiveRunSignalsResponses, type GetPrepareStatusData, type GetPrepareStatusError, type GetPrepareStatusErrors, type GetPrepareStatusResponse, type GetPrepareStatusResponses, type GetStrategyCodeData, type GetStrategyCodeError, type GetStrategyCodeErrors, type GetStrategyCodeResponse, type GetStrategyCodeResponses, type GetStrategyData, type GetStrategyError, type GetStrategyErrors, type GetStrategyResponse, type GetStrategyResponses, type GetSweepResultData, type GetSweepResultError, type GetSweepResultErrors, type GetSweepResultResponse, type GetSweepResultResponses, type GetSweepRunEquityCurveData, type GetSweepRunEquityCurveError, type GetSweepRunEquityCurveErrors, type GetSweepRunEquityCurveResponse, type GetSweepRunEquityCurveResponses, type GetSweepSensitivityData, type GetSweepSensitivityError, type GetSweepSensitivityErrors, type GetSweepSensitivityResponse, type GetSweepSensitivityResponses, type HalLink, type ImportDatasetData, type ImportDatasetError, type ImportDatasetErrors, type ImportDatasetResponse, type ImportDatasetResponses, type Instrument, type InstrumentCoverage, type InstrumentDetail, type InstrumentLinks, type InstrumentListMeta, type InstrumentListResponse, type JobState, type ListDatasetsData, type ListDatasetsResponse, type ListDatasetsResponses, type ListExchangesData, type ListExchangesResponse, type ListExchangesResponses, type ListInstrumentsData, type ListInstrumentsError, type ListInstrumentsErrors, type ListInstrumentsResponse, type ListInstrumentsResponses, type ListLiveData, type ListLiveError, type ListLiveErrors, type ListLiveResponse, type ListLiveResponses, type ListPublicLiveData, type ListPublicLiveError, type ListPublicLiveErrors, type ListPublicLiveResponse, type ListPublicLiveResponses, type ListSegmentInstrumentsData, type ListSegmentInstrumentsError, type ListSegmentInstrumentsErrors, type ListSegmentInstrumentsResponse, type ListSegmentInstrumentsResponses, type ListStrategiesData, type ListStrategiesResponse, type ListStrategiesResponses, type LiveConnectionToken, type LiveListResponse, type LiveParamsUpdateResult, type LiveRun, type LiveRunCompact, type LiveRunSummary, type LiveSignal, type LiveSignalInstrument, type LiveSignalOrder, type LiveSignalPage, type LiveSource, type MintLiveConnectionTokenData, type MintLiveConnectionTokenResponse, type MintLiveConnectionTokenResponses, type Notice, type OpenDatasetUploadData, type OpenDatasetUploadError, type OpenDatasetUploadErrors, type OpenDatasetUploadResponse, type OpenDatasetUploadResponses, type Options, type PrepareBacktestData, type PrepareBacktestError, type PrepareBacktestErrors, type PrepareBacktestResponse, type PrepareBacktestResponses, type PrepareJobState, type PrepareRequest, type PublicLiveListLinks, type PublicLiveListResponse, type PublicLiveNextLink, type PublicLiveRun, type ResponseError, type ResultMap, type ScalarStrategyParamValue, type StartLiveData, type StartLiveError, type StartLiveErrors, type StartLiveRequest, type StartLiveResponse, type StartLiveResponses, type StopLiveData, type StopLiveError, type StopLiveErrors, type StopLiveResponse, type StopLiveResponses, type StrategyId, type StrategyLinks, type StrategyState, type StrategySummary, type SweepAxis, type SweepBaseConfig, type SweepHeatmap, type SweepHeatmapCell, type SweepMarginal, type SweepMarginalPoint, type SweepProgress, type SweepRunRow, type SweepSensitivity, type SweepSpecRequest, type UpdateLiveData, type UpdateLiveError, type UpdateLiveErrors, type UpdateLiveParamsData, type UpdateLiveParamsError, type UpdateLiveParamsErrors, type UpdateLiveParamsRequest, type UpdateLiveParamsResponse, type UpdateLiveParamsResponses, type UpdateLiveRequest, type UpdateLiveResponse, type UpdateLiveResponses, type ValidateStrategyData, type ValidateStrategyError, type ValidateStrategyErrors, type ValidateStrategyResponse, type ValidateStrategyResponses, type WalkForwardAccepted, type WalkForwardFold, type WalkForwardRequest, type WalkForwardResult, authenticate, cancelBacktest, cancelSweep, client, compileStrategy, createDataset, deleteDataset, deleteStrategy, downloadKlines, downloadTickers, executeBacktest, executeSweep, finalizeDatasetUpload, getAccount, getAccountUsage, getBacktestResult, getDataset, getDatasetImport, getDatasetUpload, getLive, getLiveRunSignals, getPrepareStatus, getStrategy, getStrategyCode, getSweepResult, getSweepRunEquityCurve, getSweepSensitivity, importDataset, listDatasets, listExchanges, listInstruments, listLive, listPublicLive, listSegmentInstruments, listStrategies, mintLiveConnectionToken, openDatasetUpload, prepareBacktest, startLive, stopLive, updateLive, updateLiveParams, validateStrategy };
+export { type AcceptedJob, type Account, type AccountLinks, type AccountUsage, type AccountUsageLinks, type AuthTokenError, type AuthTokenResponse, type AuthenticateData, type AuthenticateError, type AuthenticateErrors, type AuthenticateResponse, type AuthenticateResponses, type BacktestJobResult, type CancelBacktestData, type CancelBacktestError, type CancelBacktestErrors, type CancelBacktestResponse, type CancelBacktestResponses, type CancelSweepData, type CancelSweepError, type CancelSweepErrors, type CancelSweepResponse, type CancelSweepResponses, type ClientOptions, type CompileStrategyData, type CompileStrategyError, type CompileStrategyErrors, type CompileStrategyResponse, type CompileStrategyResponses, type CoverageWindow, type CreateDatasetData, type CreateDatasetError, type CreateDatasetErrors, type CreateDatasetResponse, type CreateDatasetResponses, type DataSourceType, type Dataset, type DatasetCreated, type DatasetImportCreated, type DatasetImportDexRequest, type DatasetImportRequest, type DatasetImportState, type DatasetUploadSession, type DatasetUploadState, type DatasetUploadTarget, type DatasetVersion, type DatasetWithLinks, type DeclaredProperty, type DeleteDatasetData, type DeleteDatasetError, type DeleteDatasetErrors, type DeleteDatasetResponse, type DeleteDatasetResponses, type DeleteStrategyData, type DeleteStrategyError, type DeleteStrategyErrors, type DeleteStrategyResponse, type DeleteStrategyResponses, type DownloadKlinesData, type DownloadKlinesError, type DownloadKlinesErrors, type DownloadKlinesResponse, type DownloadKlinesResponses, type DownloadTickersData, type DownloadTickersError, type DownloadTickersErrors, type DownloadTickersResponse, type DownloadTickersResponses, type EquityCurveMeta, type EquityCurveOptions, type EquityCurveOutMode, type EquityCurveRequest, type EquityCurveResult, type EquityPoint, type Exchange, type ExecuteBacktestData, type ExecuteBacktestError, type ExecuteBacktestErrors, type ExecuteBacktestResponse, type ExecuteBacktestResponses, type ExecuteSweepAccepted, type ExecuteSweepData, type ExecuteSweepError, type ExecuteSweepErrors, type ExecuteSweepRequest, type ExecuteSweepResponse, type ExecuteSweepResponses, type ExecuteSweepResult, type FinalizeDatasetUploadData, type FinalizeDatasetUploadError, type FinalizeDatasetUploadErrors, type FinalizeDatasetUploadResponse, type FinalizeDatasetUploadResponses, type GetAccountData, type GetAccountResponse, type GetAccountResponses, type GetAccountUsageData, type GetAccountUsageResponse, type GetAccountUsageResponses, type GetBacktestResultData, type GetBacktestResultError, type GetBacktestResultErrors, type GetBacktestResultResponse, type GetBacktestResultResponses, type GetDatasetData, type GetDatasetError, type GetDatasetErrors, type GetDatasetImportData, type GetDatasetImportError, type GetDatasetImportErrors, type GetDatasetImportResponse, type GetDatasetImportResponses, type GetDatasetResponse, type GetDatasetResponses, type GetDatasetUploadData, type GetDatasetUploadError, type GetDatasetUploadErrors, type GetDatasetUploadResponse, type GetDatasetUploadResponses, type GetLiveData, type GetLiveError, type GetLiveErrors, type GetLiveResponse, type GetLiveResponses, type GetLiveRunPaperData, type GetLiveRunPaperEquityData, type GetLiveRunPaperEquityError, type GetLiveRunPaperEquityErrors, type GetLiveRunPaperEquityResponse, type GetLiveRunPaperEquityResponses, type GetLiveRunPaperError, type GetLiveRunPaperErrors, type GetLiveRunPaperResponse, type GetLiveRunPaperResponses, type GetLiveRunSignalsData, type GetLiveRunSignalsError, type GetLiveRunSignalsErrors, type GetLiveRunSignalsResponse, type GetLiveRunSignalsResponses, type GetPrepareStatusData, type GetPrepareStatusError, type GetPrepareStatusErrors, type GetPrepareStatusResponse, type GetPrepareStatusResponses, type GetStrategyCodeData, type GetStrategyCodeError, type GetStrategyCodeErrors, type GetStrategyCodeResponse, type GetStrategyCodeResponses, type GetStrategyData, type GetStrategyError, type GetStrategyErrors, type GetStrategyResponse, type GetStrategyResponses, type GetSweepResultData, type GetSweepResultError, type GetSweepResultErrors, type GetSweepResultResponse, type GetSweepResultResponses, type GetSweepRunEquityCurveData, type GetSweepRunEquityCurveError, type GetSweepRunEquityCurveErrors, type GetSweepRunEquityCurveResponse, type GetSweepRunEquityCurveResponses, type GetSweepSensitivityData, type GetSweepSensitivityError, type GetSweepSensitivityErrors, type GetSweepSensitivityResponse, type GetSweepSensitivityResponses, type HalLink, type ImportDatasetData, type ImportDatasetError, type ImportDatasetErrors, type ImportDatasetResponse, type ImportDatasetResponses, type Instrument, type InstrumentCoverage, type InstrumentDetail, type InstrumentLinks, type InstrumentListMeta, type InstrumentListResponse, type JobState, type ListDatasetsData, type ListDatasetsResponse, type ListDatasetsResponses, type ListExchangesData, type ListExchangesResponse, type ListExchangesResponses, type ListInstrumentsData, type ListInstrumentsError, type ListInstrumentsErrors, type ListInstrumentsResponse, type ListInstrumentsResponses, type ListLiveData, type ListLiveError, type ListLiveErrors, type ListLiveResponse, type ListLiveResponses, type ListPublicLiveData, type ListPublicLiveError, type ListPublicLiveErrors, type ListPublicLiveResponse, type ListPublicLiveResponses, type ListSegmentInstrumentsData, type ListSegmentInstrumentsError, type ListSegmentInstrumentsErrors, type ListSegmentInstrumentsResponse, type ListSegmentInstrumentsResponses, type ListStrategiesData, type ListStrategiesResponse, type ListStrategiesResponses, type LiveCommandResult, type LiveConnectionToken, type LiveListResponse, type LivePaper, type LivePaperAccount, type LivePaperConfig, type LivePaperEquityPage, type LivePaperEquityPoint, type LivePaperKpi, type LivePaperPosition, type LiveParamsUpdateResult, type LiveRun, type LiveRunCompact, type LiveRunSummary, type LiveSignal, type LiveSignalInstrument, type LiveSignalOrder, type LiveSignalPage, type LiveSource, type MintLiveConnectionTokenData, type MintLiveConnectionTokenResponse, type MintLiveConnectionTokenResponses, type Notice, type OpenDatasetUploadData, type OpenDatasetUploadError, type OpenDatasetUploadErrors, type OpenDatasetUploadResponse, type OpenDatasetUploadResponses, type Options, type PrepareBacktestData, type PrepareBacktestError, type PrepareBacktestErrors, type PrepareBacktestResponse, type PrepareBacktestResponses, type PrepareJobState, type PrepareRequest, type PublicLiveListLinks, type PublicLiveListResponse, type PublicLiveNextLink, type PublicLiveRun, type ResponseError, type ResultMap, type ScalarStrategyParamValue, type SendLiveCommandData, type SendLiveCommandError, type SendLiveCommandErrors, type SendLiveCommandRequest, type SendLiveCommandResponse, type SendLiveCommandResponses, type StartLiveData, type StartLiveError, type StartLiveErrors, type StartLiveRequest, type StartLiveResponse, type StartLiveResponses, type StopLiveData, type StopLiveError, type StopLiveErrors, type StopLiveResponse, type StopLiveResponses, type StrategyId, type StrategyLinks, type StrategyState, type StrategySummary, type SweepAxis, type SweepBaseConfig, type SweepHeatmap, type SweepHeatmapCell, type SweepMarginal, type SweepMarginalPoint, type SweepProgress, type SweepRunRow, type SweepSensitivity, type SweepSpecRequest, type UpdateLiveData, type UpdateLiveError, type UpdateLiveErrors, type UpdateLiveParamsData, type UpdateLiveParamsError, type UpdateLiveParamsErrors, type UpdateLiveParamsRequest, type UpdateLiveParamsResponse, type UpdateLiveParamsResponses, type UpdateLiveRequest, type UpdateLiveResponse, type UpdateLiveResponses, type ValidateStrategyData, type ValidateStrategyError, type ValidateStrategyErrors, type ValidateStrategyResponse, type ValidateStrategyResponses, type WalkForwardAccepted, type WalkForwardFold, type WalkForwardRequest, type WalkForwardResult, authenticate, cancelBacktest, cancelSweep, client, compileStrategy, createDataset, deleteDataset, deleteStrategy, downloadKlines, downloadTickers, executeBacktest, executeSweep, finalizeDatasetUpload, getAccount, getAccountUsage, getBacktestResult, getDataset, getDatasetImport, getDatasetUpload, getLive, getLiveRunPaper, getLiveRunPaperEquity, getLiveRunSignals, getPrepareStatus, getStrategy, getStrategyCode, getSweepResult, getSweepRunEquityCurve, getSweepSensitivity, importDataset, listDatasets, listExchanges, listInstruments, listLive, listPublicLive, listSegmentInstruments, listStrategies, mintLiveConnectionToken, openDatasetUpload, prepareBacktest, sendLiveCommand, startLive, stopLive, updateLive, updateLiveParams, validateStrategy };