@qtsurfer/api-client 0.19.0 → 0.21.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
@@ -1158,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.
@@ -1269,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.
      */
@@ -1709,13 +1748,23 @@ 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;
+    /**
+     * Ask for a **stream URL**: a secret address that a simple client, or a service that passes your signals
+     * on to others, can open as a plain WebSocket to receive this run's signals as they are produced, one JSON
+     * text frame per signal, with none of the live-execution protocol around it. The URL comes back as
+     * `streamUrl` in the response to this call. Available from the `sandbox` stage on, on the plans that may
+     * broadcast; any other plan gets `429`. It can be asked for **only when the run is started** (not added
+     * later), and it also turns `relay` on. See the "Live execution" guide, "A plain WebSocket stream of a run".
+     *
+     */
+    stream?: boolean;
     name?: string;
     description?: string;
     paper?: LivePaperConfig;
@@ -1772,6 +1821,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.
  */
@@ -1785,11 +1846,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;
     /**
@@ -1797,7 +1858,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>;
@@ -1809,7 +1880,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;
     /**
@@ -1817,7 +1888,7 @@ 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;
@@ -1826,6 +1897,97 @@ type LiveRun = {
      * The run's paper trading configuration as accepted at start, normalised. Absent when the run has no paper trading.
      */
     paper?: LivePaperConfig;
+    /**
+     * The run's latest counters. Returned by the two reads, `GET /strategy/{strategyId}/live` and
+     * `GET /live/{runId}`; never by starting or stopping a run. Absent until the first snapshot exists
+     * (a run that has just started), and absent is not zero.
+     *
+     */
+    stats?: LiveRunStats;
+};
+/**
+ * What a run has been doing, as of its last snapshot. The platform refreshes it about once a minute
+ * while the run is being executed, so `opsPerSecond` is an average over that interval, not an
+ * instantaneous rate.
+ *
+ */
+type LiveRunStats = {
+    /**
+     * Updates of instruments the run has accepted since it started executing. It can start again from zero if the run is restarted.
+     */
+    processed: number;
+    /**
+     * Updates accepted per second over the last refresh interval. `0` when none arrived.
+     */
+    opsPerSecond: number;
+    /**
+     * How many distinct instruments the run has received an update for.
+     */
+    instrumentsSeen: number;
+    /**
+     * Epoch milliseconds when these counters were last written.
+     */
+    asOfMs: number;
+    /**
+     * Epoch milliseconds of the last snapshot in which `processed` had grown. Absent until the run has
+     * processed anything. A run fed by a source that updates rarely (a funding rate, for example) can
+     * stay flat for hours: that is how such a run behaves, not a fault.
+     *
+     */
+    progressedAtMs?: number;
+    /**
+     * `true` when the run is meant to be running (`desired` is `RUNNING`) and its counters have not
+     * been refreshed for several refresh intervals: the platform has stopped updating them, which is
+     * worth checking against `state`. `false` otherwise. A run whose `processed` is flat is not stale;
+     * `progressedAtMs` is how to tell it apart.
+     *
+     */
+    stale: boolean;
+};
+/**
+ * A run as returned by `GET /live/{runId}`, the full state of `LiveRun` plus when it last changed.
+ */
+type LiveRunDetail = LiveRun & {
+    /**
+     * Epoch milliseconds of the run's last change, from any cause. It only moves forward, so of two reads of the same run the one with the larger value is the newer.
+     */
+    updatedAtMs: number;
+};
+/**
+ * A run as `LiveRun` describes it, plus its `streamUrl` when it has one. It is what **starting a run** and
+ * `GET /strategy/{strategyId}/live` return: your own run, read with your own credentials. Stopping a run
+ * and `GET /live/{runId}` return `LiveRun`, which never carries the URL.
+ *
+ */
+type LiveRunWithStream = LiveRun & {
+    /**
+     * The run's secret stream URL (`wss://…`). **Treat it like a password**: anyone who holds it can read
+     * this run's signals, from the sandbox stage on. Present only when the run was started with
+     * `stream: true`, is wanted running, has not had its stream revoked, and your plan still lets you
+     * broadcast; absent otherwise (a plan that lets you broadcast again gets the same URL back). Rotate
+     * it with `POST /live/{runId}/stream` if it leaks, revoke it with `DELETE /live/{runId}/stream`.
+     *
+     */
+    streamUrl?: string;
+};
+/**
+ * A run's new stream URL, as returned by `POST /live/{runId}/stream`.
+ */
+type LiveStreamUrl = {
+    /**
+     * The run's new secret stream URL. The previous one has stopped working.
+     */
+    streamUrl: string;
+};
+/**
+ * What `DELETE /live/{runId}/stream` returns.
+ */
+type LiveStreamRevoked = {
+    runId: string;
+    /**
+     * Always `true`.
+     */
+    revoked: boolean;
 };
 /**
  * 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.
@@ -1852,17 +2014,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.
@@ -2055,7 +2231,7 @@ type LiveSignal = {
     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;
@@ -2102,6 +2278,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;
@@ -2338,7 +2525,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 = {
@@ -2368,6 +2562,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.
      */
@@ -2619,7 +2817,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;
@@ -2961,7 +3161,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 = {
@@ -3118,7 +3325,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;
     /**
@@ -3286,9 +3493,9 @@ type GetLiveErrors = {
 type GetLiveError = GetLiveErrors[keyof GetLiveErrors];
 type GetLiveResponses = {
     /**
-     * The run's current state
+     * The run's current state, with its `streamUrl` when it has one
      */
-    200: LiveRun;
+    200: LiveRunWithStream;
 };
 type GetLiveResponse = GetLiveResponses[keyof GetLiveResponses];
 type StartLiveData = {
@@ -3304,7 +3511,7 @@ type StartLiveData = {
 };
 type StartLiveErrors = {
     /**
-     * Malformed `sources` (not exactly one entry, missing field, unsupported `type`), 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.
+     * 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. A `relay` or `stream` that is not `true` or `false`, or a `stream` where streams are not available yet.
      */
     400: ResponseError;
     /**
@@ -3316,9 +3523,10 @@ type StartLiveErrors = {
      */
     409: ResponseError;
     /**
-     * Your plan does not include live runs, would exceed your concurrent-run or
-     * instrument-count limit, or the platform is at capacity right now. Carries a
-     * `Retry-After` header.
+     * One of two kinds. **Your plan** does not include live runs, would exceed your concurrent-run or
+     * instrument-count limit, or does not let you ask for a `stream`: the message names your plan, and
+     * retrying will not help until something changes, so there is no `Retry-After`. Or **the platform is at
+     * capacity** right now: a `Retry-After` header says when to try again.
      *
      */
     429: ResponseError;
@@ -3326,9 +3534,9 @@ type StartLiveErrors = {
 type StartLiveError = StartLiveErrors[keyof StartLiveErrors];
 type StartLiveResponses = {
     /**
-     * Started — the run's own state, in the sandbox stage
+     * Started — the run's own state, in the sandbox stage, with its `streamUrl` when you asked for a stream
      */
-    201: LiveRun;
+    201: LiveRunWithStream;
 };
 type StartLiveResponse = StartLiveResponses[keyof StartLiveResponses];
 type ListLiveData = {
@@ -3389,6 +3597,31 @@ type ListPublicLiveResponses = {
     200: PublicLiveListResponse;
 };
 type ListPublicLiveResponse = ListPublicLiveResponses[keyof ListPublicLiveResponses];
+type GetLiveRunData = {
+    body?: never;
+    path: {
+        /**
+         * The `runId` from `POST`/`GET`/`DELETE` `.../live`, from `GET /live` or from `GET /live/public`
+         */
+        runId: string;
+    };
+    query?: never;
+    url: "/live/{runId}";
+};
+type GetLiveRunErrors = {
+    /**
+     * No such run, or you do not own it — the two look identical on purpose.
+     */
+    404: ResponseError;
+};
+type GetLiveRunError = GetLiveRunErrors[keyof GetLiveRunErrors];
+type GetLiveRunResponses = {
+    /**
+     * The run
+     */
+    200: LiveRunDetail;
+};
+type GetLiveRunResponse = GetLiveRunResponses[keyof GetLiveRunResponses];
 type UpdateLiveData = {
     body?: UpdateLiveRequest;
     path: {
@@ -3436,7 +3669,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;
 };
@@ -3448,6 +3681,106 @@ 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 RevokeLiveStreamData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: "/live/{runId}/stream";
+};
+type RevokeLiveStreamErrors = {
+    /**
+     * No such run, or you do not own it.
+     */
+    404: ResponseError;
+    /**
+     * The run was started without a stream, so there is nothing to revoke.
+     */
+    409: ResponseError;
+};
+type RevokeLiveStreamError = RevokeLiveStreamErrors[keyof RevokeLiveStreamErrors];
+type RevokeLiveStreamResponses = {
+    /**
+     * Revoked (or already revoked).
+     */
+    200: LiveStreamRevoked;
+};
+type RevokeLiveStreamResponse = RevokeLiveStreamResponses[keyof RevokeLiveStreamResponses];
+type RotateLiveStreamData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: "/live/{runId}/stream";
+};
+type RotateLiveStreamErrors = {
+    /**
+     * No such run, or you do not own it.
+     */
+    404: ResponseError;
+    /**
+     * One of three reasons, each its own message: the run was started without a stream; its stream was
+     * revoked (a revoked stream cannot be restored: start the run again with a stream); or the run is stopped.
+     *
+     */
+    409: ResponseError;
+    /**
+     * Your plan does not let you broadcast a run's signals. The message names your plan; retrying will not help until it changes, so there is no `Retry-After`.
+     */
+    429: ResponseError;
+};
+type RotateLiveStreamError = RotateLiveStreamErrors[keyof RotateLiveStreamErrors];
+type RotateLiveStreamResponses = {
+    /**
+     * The new URL.
+     */
+    200: LiveStreamUrl;
+};
+type RotateLiveStreamResponse = RotateLiveStreamResponses[keyof RotateLiveStreamResponses];
 type GetLiveRunSignalsData = {
     body?: never;
     path: {
@@ -3707,6 +4040,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>;
@@ -3728,6 +4065,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.
@@ -4021,6 +4363,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>;
@@ -4155,7 +4501,8 @@ declare const getDatasetImport: <ThrowOnError extends boolean = false>(options:
  * Requests a stop. The run winds down at its own next check-in rather than instantly —
  * poll `GET`/`PATCH` `.../live` and expect `state` to remain `RUNNING` for a short window
  * after `desired` flips to `STOPPED`. Calling this again on an already-stopped run is not an
- * error; it returns the same (unchanged) state.
+ * error; it returns the same (unchanged) state. A stopped run has no stream: its `streamUrl`, if it had one,
+ * stops working and is not in this response.
  *
  */
 declare const stopLive: <ThrowOnError extends boolean = false>(options: Options<StopLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRun, ResponseError, ThrowOnError>;
@@ -4163,10 +4510,15 @@ declare const stopLive: <ThrowOnError extends boolean = false>(options: Options<
  * Get this strategy's current (or most recent) live run
  * The run you last started for this strategy — its most complete state, including `params`
  * and the promotion `gate` once the sandbox trial has one to report. Returns the run's last
- * known state even after it has stopped; this endpoint never disappears history.
+ * known state even after it has stopped; this endpoint never disappears history. When the run was started
+ * with a `stream`, `streamUrl` is here too while the run is running and your plan allows it.
+ *
+ * While the run is being executed it also carries `stats`, the run's latest counters (updates
+ * processed, rate, instruments seen), refreshed about once a minute. Starting or stopping a run
+ * does not return them; read them here.
  *
  */
-declare const getLive: <ThrowOnError extends boolean = false>(options: Options<GetLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRun, ResponseError, ThrowOnError>;
+declare const getLive: <ThrowOnError extends boolean = false>(options: Options<GetLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRunWithStream, ResponseError, ThrowOnError>;
 /**
  * Start a strategy on a live market feed
  * Starts your strategy against a live market feed. A new run always begins in the **sandbox**
@@ -4202,8 +4554,13 @@ declare const getLive: <ThrowOnError extends boolean = false>(options: Options<G
  * (it overrides `getExecutionCallback()`) has no other execution venue, so it cannot start
  * without a `paper` block.
  *
+ * **A plain WebSocket stream.** Pass `stream: true` to get a secret URL for this run's signals that a simple
+ * client, or a service that passes them on to others, can open as an ordinary WebSocket, from the sandbox stage
+ * on. The URL is in the response (`streamUrl`) and in `GET /strategy/{strategyId}/live`; treat it like a
+ * password. See the "Live execution" guide.
+ *
  */
-declare const startLive: <ThrowOnError extends boolean = false>(options: Options<StartLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRun, ResponseError, ThrowOnError>;
+declare const startLive: <ThrowOnError extends boolean = false>(options: Options<StartLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRunWithStream, ResponseError, ThrowOnError>;
 /**
  * List your own live runs
  * Every run you have started, in any `stage`, `desired` state, or `visibility` — newest
@@ -4214,13 +4571,30 @@ 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.
  *
  */
 declare const listPublicLive: <ThrowOnError extends boolean = false>(options?: Options<ListPublicLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<PublicLiveListResponse, ResponseError, ThrowOnError>;
+/**
+ * Read one of your runs by its id
+ * Owner only, addressed by `runId` directly rather than through its strategy: the run's own
+ * canonical identity, which is what `POST`/`GET`/`DELETE` `.../live`, `GET /live` and
+ * `GET /live/public` all hand out. Use it to re-read one specific run — including one you
+ * stopped long ago or that is no longer your strategy's most recent — without paging through
+ * `GET /live`.
+ *
+ * Returns the same state as `GET /strategy/{strategyId}/live` (`strategyId` is the strategy's
+ * id, and `stats` is there too), plus `updatedAtMs`: when the run last changed, from any cause — a
+ * state change, a promotion, a parameter update, a stop. A refresh of `stats` is not a change of
+ * the run and does not move `updatedAtMs`. A run that is public is reachable by others through
+ * `GET /live/public`, never through this route.
+ *
+ */
+declare const getLiveRun: <ThrowOnError extends boolean = false>(options: Options<GetLiveRunData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRunDetail, ResponseError, ThrowOnError>;
 /**
  * Change a run's visibility, name, or description
  * Owner only, addressed by `runId` directly rather than through its strategy — this is a
@@ -4248,6 +4622,45 @@ 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>;
+/**
+ * Revoke a run's stream URL
+ * Revokes a run's stream URL **for good**: connections open on it are closed within about 15 seconds and it
+ * answers `404` from then on. The run itself is not touched, and a stream cannot be added to it again; start
+ * the run again with `stream: true` for a new URL. Owner only, and always allowed, whatever your plan or the
+ * run's state. Repeating it is not an error.
+ *
+ */
+declare const revokeLiveStream: <ThrowOnError extends boolean = false>(options: Options<RevokeLiveStreamData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveStreamRevoked, ResponseError, ThrowOnError>;
+/**
+ * Rotate a run's stream URL
+ * Gives a run a **new** stream URL and retires the old one: connections open on the old URL are closed
+ * within about 15 seconds and the old URL answers `404` from then on. Use it when the URL may have leaked.
+ * Owner only, and only for a run that is running and was started with `stream: true` (the URL cannot be added
+ * to a run later, and a revoked one cannot be brought back). The plan is checked again: a plan that may not
+ * broadcast gets `429`.
+ *
+ * See the "Live execution" guide, "A plain WebSocket stream of a run".
+ *
+ */
+declare const rotateLiveStream: <ThrowOnError extends boolean = false>(options: Options<RotateLiveStreamData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveStreamUrl, ResponseError, ThrowOnError>;
 /**
  * Read a run's signals
  * Returns one page of the signals a run has already produced, newest-last, optionally from a
@@ -4271,8 +4684,9 @@ 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>;
@@ -4288,8 +4702,8 @@ declare const getLiveRunSignals: <ThrowOnError extends boolean = false>(options:
  * 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`. A run started without
- * a `paper` block answers `404`.
+ * 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>;
@@ -4304,7 +4718,8 @@ declare const getLiveRunPaper: <ThrowOnError extends boolean = false>(options: O
  * `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`.
+ * 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>;
@@ -4320,4 +4735,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 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 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 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, 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 GetLiveRunData, type GetLiveRunError, type GetLiveRunErrors, type GetLiveRunPaperData, type GetLiveRunPaperEquityData, type GetLiveRunPaperEquityError, type GetLiveRunPaperEquityErrors, type GetLiveRunPaperEquityResponse, type GetLiveRunPaperEquityResponses, type GetLiveRunPaperError, type GetLiveRunPaperErrors, type GetLiveRunPaperResponse, type GetLiveRunPaperResponses, type GetLiveRunResponse, type GetLiveRunResponses, 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 LiveRunDetail, type LiveRunStats, type LiveRunSummary, type LiveRunWithStream, type LiveSignal, type LiveSignalInstrument, type LiveSignalOrder, type LiveSignalPage, type LiveSource, type LiveStreamRevoked, type LiveStreamUrl, 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 RevokeLiveStreamData, type RevokeLiveStreamError, type RevokeLiveStreamErrors, type RevokeLiveStreamResponse, type RevokeLiveStreamResponses, type RotateLiveStreamData, type RotateLiveStreamError, type RotateLiveStreamErrors, type RotateLiveStreamResponse, type RotateLiveStreamResponses, 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, getLiveRun, getLiveRunPaper, getLiveRunPaperEquity, getLiveRunSignals, getPrepareStatus, getStrategy, getStrategyCode, getSweepResult, getSweepRunEquityCurve, getSweepSensitivity, importDataset, listDatasets, listExchanges, listInstruments, listLive, listPublicLive, listSegmentInstruments, listStrategies, mintLiveConnectionToken, openDatasetUpload, prepareBacktest, revokeLiveStream, rotateLiveStream, sendLiveCommand, startLive, stopLive, updateLive, updateLiveParams, validateStrategy };