@qtsurfer/api-client 0.19.0 → 0.21.0

package/src/generated/sdk.gen.ts

@@ -115,12 +115,24 @@ import type {
   ListPublicLiveData,
   ListPublicLiveResponse,
   ListPublicLiveError,
+  GetLiveRunData,
+  GetLiveRunResponse,
+  GetLiveRunError,
   UpdateLiveData,
   UpdateLiveResponse,
   UpdateLiveError,
   UpdateLiveParamsData,
   UpdateLiveParamsResponse,
   UpdateLiveParamsError,
+  SendLiveCommandData,
+  SendLiveCommandResponse,
+  SendLiveCommandError,
+  RevokeLiveStreamData,
+  RevokeLiveStreamResponse,
+  RevokeLiveStreamError,
+  RotateLiveStreamData,
+  RotateLiveStreamResponse,
+  RotateLiveStreamError,
   GetLiveRunSignalsData,
   GetLiveRunSignalsResponse,
   GetLiveRunSignalsError,
@@ -374,6 +386,10 @@ export const downloadKlines = <ThrowOnError extends boolean = false>(
  * 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.
+ *
  */
 export const listStrategies = <ThrowOnError extends boolean = false>(
   options?: Options<ListStrategiesData, ThrowOnError>
@@ -411,6 +427,11 @@ export const listStrategies = <ThrowOnError extends boolean = false>(
  * 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.
@@ -976,6 +997,10 @@ export const getBacktestResult = <ThrowOnError extends boolean = false>(
  * 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.
+ *
  */
 export const listDatasets = <ThrowOnError extends boolean = false>(
   options?: Options<ListDatasetsData, ThrowOnError>
@@ -1273,7 +1298,8 @@ export const getDatasetImport = <ThrowOnError extends boolean = false>(
  * 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.
  *
  */
 export const stopLive = <ThrowOnError extends boolean = false>(
@@ -1299,7 +1325,12 @@ export const stopLive = <ThrowOnError extends boolean = false>(
  * 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.
  *
  */
 export const getLive = <ThrowOnError extends boolean = false>(
@@ -1356,6 +1387,11 @@ export const getLive = <ThrowOnError extends boolean = false>(
  * (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.
+ *
  */
 export const startLive = <ThrowOnError extends boolean = false>(
   options: Options<StartLiveData, ThrowOnError>
@@ -1408,8 +1444,9 @@ export const listLive = <ThrowOnError extends boolean = false>(
 
 /**
  * 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.
  *
@@ -1427,6 +1464,40 @@ export const listPublicLive = <ThrowOnError extends boolean = false>(
   });
 };
 
+/**
+ * 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.
+ *
+ */
+export const getLiveRun = <ThrowOnError extends boolean = false>(
+  options: Options<GetLiveRunData, ThrowOnError>
+) => {
+  return (options.client ?? _heyApiClient).get<
+    GetLiveRunResponse,
+    GetLiveRunError,
+    ThrowOnError
+  >({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http",
+      },
+    ],
+    url: "/live/{runId}",
+    ...options,
+  });
+};
+
 /**
  * Change a run's visibility, name, or description
  * Owner only, addressed by `runId` directly rather than through its strategy — this is a
@@ -1498,6 +1569,103 @@ export const updateLiveParams = <ThrowOnError extends boolean = false>(
   });
 };
 
+/**
+ * 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.
+ *
+ */
+export const sendLiveCommand = <ThrowOnError extends boolean = false>(
+  options: Options<SendLiveCommandData, ThrowOnError>
+) => {
+  return (options.client ?? _heyApiClient).post<
+    SendLiveCommandResponse,
+    SendLiveCommandError,
+    ThrowOnError
+  >({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http",
+      },
+    ],
+    url: "/live/{runId}/commands",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers,
+    },
+  });
+};
+
+/**
+ * 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.
+ *
+ */
+export const revokeLiveStream = <ThrowOnError extends boolean = false>(
+  options: Options<RevokeLiveStreamData, ThrowOnError>
+) => {
+  return (options.client ?? _heyApiClient).delete<
+    RevokeLiveStreamResponse,
+    RevokeLiveStreamError,
+    ThrowOnError
+  >({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http",
+      },
+    ],
+    url: "/live/{runId}/stream",
+    ...options,
+  });
+};
+
+/**
+ * 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".
+ *
+ */
+export const rotateLiveStream = <ThrowOnError extends boolean = false>(
+  options: Options<RotateLiveStreamData, ThrowOnError>
+) => {
+  return (options.client ?? _heyApiClient).post<
+    RotateLiveStreamResponse,
+    RotateLiveStreamError,
+    ThrowOnError
+  >({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http",
+      },
+    ],
+    url: "/live/{runId}/stream",
+    ...options,
+  });
+};
+
 /**
  * Read a run's signals
  * Returns one page of the signals a run has already produced, newest-last, optionally from a
@@ -1521,8 +1689,9 @@ export const updateLiveParams = <ThrowOnError extends boolean = false>(
  * 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.
  *
  */
 export const getLiveRunSignals = <ThrowOnError extends boolean = false>(
@@ -1556,8 +1725,8 @@ export const getLiveRunSignals = <ThrowOnError extends boolean = false>(
  * 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`.
  *
  */
 export const getLiveRunPaper = <ThrowOnError extends boolean = false>(
@@ -1590,7 +1759,8 @@ export const getLiveRunPaper = <ThrowOnError extends boolean = false>(
  * `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.
  *
  */
 export const getLiveRunPaperEquity = <ThrowOnError extends boolean = false>(