@qtsurfer/api-client 0.23.1 → 0.25.0

package/dist/index.d.ts

@@ -13,6 +13,37 @@ type ResponseError = {
      * Error description
      */
     message: string;
+    /**
+     * A stable token naming the cause, for a client to branch on without reading `message`.
+     * Present only on an error that has one, and each operation that can return one lists
+     * the values it uses. A client treats a value it does not know like an absent `reason`.
+     *
+     */
+    reason?: string;
+    next?: ErrorNextCall;
+};
+/**
+ * The call that gets past an error, ready to send: a client that wants the same thing by
+ * another route makes this request. Present only on an error that has one.
+ *
+ */
+type ErrorNextCall = {
+    /**
+     * HTTP method of the call.
+     */
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    /**
+     * Path of the call, relative to the server URL (the one that already ends in `/v1`).
+     */
+    path: string;
+    /**
+     * JSON body of the call, when it has one. Whatever depends on the caller and cannot be
+     * known here (such as the `name` of a dataset) is left for the client to add.
+     *
+     */
+    body?: {
+        [key: string]: unknown;
+    };
 };
 /**
  * A scalar strategy property value for one execution.
@@ -22,6 +53,12 @@ type ScalarStrategyParamValue = number | string | boolean;
  * Exchange instrument identifier (e.g. a currency pair)
  */
 type Instrument = string;
+/**
+ * An exchange's instrument catalogue: centralized-exchange instruments or decentralized-exchange
+ * pools. Read `meta.venueType` to distinguish `cex` from `dex`, including when `data` is empty.
+ *
+ */
+type InstrumentCatalogueResponse = InstrumentListResponse | PoolListResponse;
 /**
  * HAL-style response envelope for the instruments listing
  */
@@ -49,6 +86,10 @@ type InstrumentListMeta = {
      * The market segment served in `data`
      */
     segment: "spot" | "futures";
+    /**
+     * The venue type of the exchange, as `GET /exchanges` lists it. Always `cex` here; a listing of pools says `dex`.
+     */
+    venueType: "cex";
 };
 /**
  * HAL `_links` — segment discovery for the instruments listing
@@ -67,6 +108,111 @@ type InstrumentLinks = {
      */
     futures?: HalLink;
 };
+/**
+ * HAL-style response envelope for the instruments listing of a decentralized exchange, whose instruments are pools
+ */
+type PoolListResponse = {
+    /**
+     * The pools worth running, the most traded in the last 24 hours first
+     */
+    data: Array<PoolDetail>;
+    meta: PoolListMeta;
+    _links: PoolLinks;
+};
+/**
+ * Metadata describing the pools listing of a decentralized exchange
+ */
+type PoolListMeta = {
+    /**
+     * When this listing was last refreshed. It is refreshed every hour, and the `lastPrice` of each pool is as of this time.
+     */
+    updatedAt: string;
+    /**
+     * The exchange the pools belong to
+     */
+    exchange: string;
+    /**
+     * The protocol served in `data`, one of the exchange's `segments`
+     */
+    segment: string;
+    /**
+     * The venue type of the exchange, as `GET /exchanges` lists it. Always `dex` here; a listing of instruments of a centralized exchange says `cex`.
+     */
+    venueType: "dex";
+    /**
+     * A pool with less liquidity than this (in US dollars) is not listed
+     */
+    minTvlUsd: number;
+    /**
+     * The most pools the listing has
+     */
+    limit: number;
+};
+/**
+ * HAL `_links` — protocol discovery for the pools listing of a decentralized exchange
+ */
+type PoolLinks = {
+    /**
+     * Link to this listing
+     */
+    self: HalLink;
+    [key: string]: HalLink;
+};
+/**
+ * A pool of a decentralized exchange that a live run can read. The listing is a place to start, not the
+ * whole market: a live run can read any pool of the protocol, listed or not.
+ *
+ */
+type PoolDetail = {
+    /**
+     * The pool's address, in lower case. It is the value to put in `instruments` of a live run's source.
+     */
+    id: string;
+    /**
+     * The pair written `BASE/QUOTE`, the way the signals of a run on this pool name it (`instrument`)
+     */
+    symbol: string;
+    /**
+     * Symbol of the base token
+     */
+    base: string;
+    /**
+     * Symbol of the quote token
+     */
+    quote: string;
+    /**
+     * Address of the base token, in lower case
+     */
+    baseAddress: string;
+    /**
+     * Address of the quote token, in lower case
+     */
+    quoteAddress: string;
+    /**
+     * The pool's fee tier, in percent (`0.05` is a 0.05 % fee). A protocol can have several pools of the same pair, one per fee tier.
+     */
+    feePercent: number;
+    /**
+     * The price of one base token in the quote token, as the signals of a run on this pool name the pair. It is as of `meta.updatedAt`, so up to one hour old. Absent when there is no price for the pool.
+     */
+    lastPrice?: number;
+    /**
+     * What traded in the pool over the last 24 hours, in the quote token, the same meaning as `volume24h` of an instrument of a centralized exchange. Absent when the quote token has no dollar price to convert from.
+     */
+    volume24h?: number;
+    /**
+     * The liquidity held by the pool, in US dollars
+     */
+    tvlUsd: number;
+    /**
+     * What traded in the pool over the last 24 hours, in US dollars
+     */
+    volume24hUsd: number;
+    /**
+     * When the pool was created. Absent when it is not known
+     */
+    createdAt?: string;
+};
 /**
  * HAL `_links` for a strategy — present on a full `StrategyState` body (`GET
  * /strategy/{strategyId}`, and `POST /strategy/{strategyId}/validate`'s already-validated
@@ -112,6 +258,7 @@ type Account = {
      * Your current subscription tier.
      */
     tier: string;
+    scopes: KeyScopes;
     /**
      * 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
@@ -227,6 +374,10 @@ type InstrumentDetail = {
      * Instrument identifier (e.g. currency pair)
      */
     id: string;
+    /**
+     * The instrument's name, the same as `id`. A pool of a decentralized exchange has the same field (`PoolDetail`), so both listings are read alike.
+     */
+    symbol: string;
     /**
      * Base currency
      */
@@ -235,13 +386,17 @@ type InstrumentDetail = {
      * Quote currency
      */
     quote: string;
+    /**
+     * Settlement currency. Present on a futures instrument only.
+     */
+    settle?: string;
     coverage?: InstrumentCoverage;
     /**
-     * Last traded price
+     * Last traded price. Absent for an instrument with no recent price.
      */
     lastPrice?: number;
     /**
-     * Trading volume in the last 24 hours (in quote currency)
+     * Trading volume in the last 24 hours (in quote currency). Absent for an instrument with no recent volume.
      */
     volume24h?: number;
 };
@@ -291,6 +446,18 @@ type Exchange = {
      * Description of the exchange
      */
     description?: string;
+    /**
+     * Venue category, written as the `venueType` of a live run's source: `cex` is a centralized exchange and `dex` a decentralized one. A `dex` exchange has no market data to prepare or backtest, so its id is not valid in the routes that take an `exchangeId`, except the two instruments routes, which list its pools (the instrument of a run on it is a pool's address).
+     */
+    venueType: "cex" | "dex";
+    /**
+     * The segments the exchange offers, written as in the path of `GET /exchange/{exchangeId}/{segment}/instruments` and as the `segment` of a live run's source. For a `cex` exchange, its market segments (`spot`, `futures`: the ones its instrument catalogues are served under); for a `dex` exchange, the protocols whose pools a run can read.
+     */
+    segments: Array<string>;
+    /**
+     * The segments among `segments` for which live data is published, so the ones a live run can read: a live run on any other segment of the exchange is refused with `400`. It can be empty (an exchange whose live data is not published yet).
+     */
+    liveSegments: Array<string>;
 };
 /**
  * Managed exchange data sources available for backtesting.
@@ -356,11 +523,10 @@ type PrepareRequest = {
      * * Managed exchange, `ticker` or `funding` — one of `1s`, `5s`, `1m`, `3m`, `5m`, `15m`,
      * `30m`, `1h`, `2h`, `4h`, `8h`, `12h`, `1d`, `1w`, `1q`; any other label returns `400`.
      * Omitted = `1s`, the publisher's native cadence.
-     * * Managed exchange, `kline` — one of `1s`, `1m`, `5m`, `15m`, `30m`, `1h`, `4h`, `1d`;
-     * any other label, including `5s`, `3m` and `8h`, returns `400` and names the accepted
-     * ones. Omitted = `1s`. This is the width of the bars a run reads: it is chosen here,
-     * once, and the same strategy can be run at several cadences by preparing the range at
-     * each.
+     * * Managed exchange, `kline` — the same labels as above, `1s` to `1q`; a label that is
+     * not a whole number of seconds returns `400`. Omitted = `1s`. This is the width of the
+     * bars a run reads: it is chosen here, once, and the same strategy can be run at
+     * several cadences by preparing the range at each.
      * * Dataset (`exchangeId: user`) — omitted = the dataset version's own discovered
      * `cadence` (see `DatasetVersion.cadence`), served as-is. Any cadence equal to or
      * coarser than it and an exact multiple of it is accepted, including ones outside the
@@ -1288,9 +1454,11 @@ type Dataset = {
      */
     name: string;
     /**
-     * `ticker` for an upload or a `dex` import with no `cadence` requested (native per-trade
-     * data). `klines` for a `dex` import that requested a candle `cadence` — pre-aggregated
-     * bars rather than raw ticks. Purely informational; both shapes are read the same way.
+     * `ticker` for an upload, a `dex` import with no `cadence` requested (native per-trade
+     * data) or a `cex` import with `dataType: ticker`. `klines` for a `dex` import that
+     * requested a candle `cadence` — pre-aggregated bars rather than raw ticks — or a `cex`
+     * import with `dataType: klines`. Purely informational; both shapes are read the same
+     * way.
      *
      */
     type: "ticker" | "klines";
@@ -1477,11 +1645,12 @@ type DatasetVersion = {
     rows?: number;
     /**
      * The cadence discovered from the data's own timestamps. Either a fixed grid — `1s`,
-     * `5s`, `15s`, `1m`, `5m`, `15m`, `30m`, `1h`, `4h`, `1d` — when at least half the
-     * intervals between consecutive rows fall on that step (small clock jitter tolerated), or
-     * `rt`: native data at the rate it was captured, each row at its own timestamp with no
-     * fixed step — per-trade on-chain swaps, block-spaced or sub-second ticks, irregular
-     * intervals. An `rt` dataset can be resampled to any fixed cadence at prepare time.
+     * `5s`, `15s`, `1m`, `3m`, `5m`, `15m`, `30m`, `1h`, `2h`, `4h`, `8h`, `12h`, `1d`,
+     * `1w` — when at least half the intervals between consecutive rows fall on that step
+     * (small clock jitter tolerated), or `rt`: native data at the rate it was captured, each
+     * row at its own timestamp with no fixed step — per-trade on-chain swaps, block-spaced
+     * or sub-second ticks, irregular intervals. An `rt` dataset can be resampled to any
+     * fixed cadence at prepare time.
      *
      */
     cadence?: string;
@@ -1554,7 +1723,8 @@ type DatasetUploadState = {
 };
 /**
  * `POST /datasets/imports`'s request body. A common block plus one type-specific block,
- * selected by `type` — `dex` is the only value today.
+ * selected by `type`: `dex` (block `dex`) or `cex` (block `cex`), the two `venueType`s of
+ * `GET /exchanges`.
  *
  */
 type DatasetImportRequest = {
@@ -1574,21 +1744,39 @@ type DatasetImportRequest = {
      */
     to: string;
     /**
-     * Optional. Omitted/blank keeps native per-trade event cadence — each swap at its own
-     * timestamp, so the resulting version's `cadence` is `rt` unless the swaps happen to sit
-     * on a fixed grid (see `DatasetVersion.cadence`). Set to `1s`, `1m` or
-     * `5m` instead to get pre-aggregated candles at that width rather than raw trades (the
-     * resulting dataset's `type` becomes `klines`); any other value is `400`. Not every
-     * network supports every cadence — an unsupported combination fails asynchronously, not
-     * at request time (see `DatasetImportState.error`).
+     * Optional; what it means, and what it accepts, depends on `type`. Any other value is
+     * `400`.
+     *
+     * * `dex` — omitted/blank keeps native per-trade event cadence: each swap at its own
+     * timestamp, so the resulting version's `cadence` is `rt` unless the swaps happen to
+     * sit on a fixed grid (see `DatasetVersion.cadence`). Set to `1s`, `1m` or `5m`
+     * instead to get pre-aggregated candles at that width rather than raw trades (the
+     * resulting dataset's `type` becomes `klines`). Not every network supports every
+     * cadence — an unsupported combination fails asynchronously, not at request time (see
+     * `DatasetImportState.error`).
+     * * `cex` — one of `1s`, `5s`, `1m`, `3m`, `5m`, `15m`, `30m`, `1h`, `2h`, `4h`, `8h`,
+     * `12h`, `1d`, `1w`, `1q`, whether `dataType` is `ticker` or `klines`. Omitted = the
+     * finest cadence every part of the range holds.
+     *
+     * For `cex` the bars are built from the finest data every part of the range holds. A
+     * `cadence` finer than that, or not an exact multiple of it, fails the import
+     * asynchronously (`failed`; the `error` names the finest cadence the range holds) rather
+     * than returning a dataset with a different cadence from the one asked for. So a range
+     * whose history changes cadence part-way (from `1m` to `1s`, say) comes out entirely at
+     * the coarser one when `cadence` is omitted: the dataset has no gap that is only a
+     * change of cadence.
      *
      */
-    cadence?: "1s" | "1m" | "5m";
+    cadence?: "1s" | "5s" | "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "8h" | "12h" | "1d" | "1w" | "1q";
     /**
-     * The source to fetch from. `dex` is the only value today.
+     * The kind of venue to import from, the same two values as the `venueType` of
+     * `GET /exchanges`: `dex` — a pool/pair's own on-chain market (block `dex`) — or `cex` —
+     * a centralized exchange's market history (block `cex`).
+     *
      */
-    type: "dex";
+    type: "dex" | "cex";
     dex?: DatasetImportDexRequest;
+    cex?: DatasetImportCexRequest;
 };
 /**
  * The `dex` source's own fields — required when `type` is `dex`. `id`/`version` are required
@@ -1630,6 +1818,32 @@ type DatasetImportDexRequest = {
      */
     factory?: string;
 };
+/**
+ * The `cex` source's own fields — required when `type` is `cex`. They name a market the way
+ * `GET /exchanges` and the instruments routes do: `exchange` is the `id` of a centralized
+ * exchange, `segment` one of its `segments`.
+ *
+ */
+type DatasetImportCexRequest = {
+    /**
+     * The id of a centralized exchange (`venueType` `cex`) of `GET /exchanges`, lower-case.
+     * A decentralized exchange's id is `400`: import its pools with `type: dex`.
+     *
+     */
+    exchange: string;
+    /**
+     * The market segment, one of the exchange's `segments`. `spot` is the only segment a
+     * `cex` import takes today, which matches `instrument` being a plain spot pair.
+     *
+     */
+    segment: "spot";
+    /**
+     * What to import, and the resulting dataset's `type`: `ticker` — the exchange's ticker
+     * series — or `klines` — its aggregated bars (open, high, low, close and volume).
+     *
+     */
+    dataType: "ticker" | "klines";
+};
 /**
  * The response to `POST /datasets/imports` — the dataset now exists, and its fetch has started.
  */
@@ -1677,7 +1891,8 @@ type DatasetImportState = {
     /**
      * A human-readable reason, present when `status` is `failed` — an unresolvable
      * pool/pair, no data in the requested range, a range older than the configured source
-     * retains, the fetch exceeding your tier's time ceiling, or any of
+     * retains, a `cex` `cadence` finer than the range holds (the message names the finest
+     * one), the fetch exceeding your tier's time ceiling, or any of
      * `DatasetUploadState.error`'s own ingest-side reasons once fetching hands off to it.
      * Durably recorded, same as on the upload path.
      *
@@ -1688,6 +1903,18 @@ type DatasetImportState = {
      */
     version?: DatasetVersion;
 };
+/**
+ * What your API key may do, as a map from a resource to the actions allowed on it. Names are
+ * lower case: `{ "backtests": ["read", "write", "execute"], "exchanges": ["read"] }`. A scope
+ * is a resource and an action: a resource is listed only with at least one action, and a key
+ * with no scope is `{}`. `GET /account` and `POST /auth/token` return the same map for the
+ * same key. The API reports the scopes of a key; it does not yet refuse an operation because
+ * a scope is missing.
+ *
+ */
+type KeyScopes = {
+    [key: string]: Array<string>;
+};
 type AuthTokenResponse = {
     /**
      * Short-lived HS256 JWT. Send as `Authorization: Bearer <token>` on all other endpoints.
@@ -1701,23 +1928,20 @@ type AuthTokenResponse = {
      * Seconds until the JWT expires (typically 3600).
      */
     expires_in: number;
-    /**
-     * Scopes granted to this token. Reserved for future use; currently always empty.
-     */
-    scopes?: Array<string>;
+    scopes?: KeyScopes;
     /**
      * Subscription tier this token was issued for. Drives rate limits and feature flags on downstream endpoints.
      */
     tier: "free" | "basic" | "pro" | "elite";
 };
 /**
- * Error envelope returned by `POST /auth/token` when the API key is rejected.
+ * Error envelope returned by `POST /auth/token` when the API key is rejected (`401`) or carries no scopes where scopes are required (`403`).
  */
 type AuthTokenError = {
     /**
      * Machine-readable error reason.
      */
-    code: "invalid_apikey" | "apikey_revoked" | "apikey_expired";
+    code: "invalid_apikey" | "apikey_revoked" | "apikey_expired" | "apikey_without_scopes";
     /**
      * Human-readable description of the failure.
      */
@@ -1728,17 +1952,23 @@ type AuthTokenError = {
  */
 type LiveSource = {
     /**
-     * Venue category. `cx` (centralized exchange) is the only one live runs support today.
+     * Venue category. `cex` is a centralized exchange and `dex` is one pool on a decentralized exchange, which takes its own `exchange`, `segment`, `type` and `instruments` (see "Sources" in the Live execution guide). `cx` and `dx`, the spellings used before, are still read as `cex` and `dex`; the run always reports the new ones.
+     */
+    venueType: "cex" | "dex";
+    /**
+     * The exchange id, as `GET /exchanges` lists it. For a `dex` source, the chain the pool is on; `robinhood` is the only one today.
      */
-    venueType: string;
     exchange: string;
+    /**
+     * The segment, as `GET /exchanges` lists it for that exchange, among its `liveSegments` (a segment with no live data is refused with `400`). For a `cex` source, the market segment (`spot` today); for a `dex` source, the protocol of the pool, `uniswap-v3` the only one today.
+     */
     segment: string;
     /**
-     * Both `ticker` and `kline` connect to the lightest (fastest) cadence available for the exchange — today, 1 tick/second on every supported exchange. Choosing a specific cadence is not offered yet.
+     * Both `ticker` and `kline` connect to the lightest (fastest) cadence available for the exchange — today, 1 tick/second on every supported exchange. Choosing a specific cadence is not offered yet. A `dex` source supports only `kline`: one candle per second of the pool's trades.
      */
     type: "ticker" | "kline";
     /**
-     * The instruments the run reads. For a run started with a list, that list as sent; for one started without `instruments`, or with `["*"]`, what the start resolved: the list of pairs the compilation of the strategy records as the instruments it accepts, when it records one, or `["*"]` for every instrument the exchange/segment offers (tier-gated). An entry is written `BASE/QUOTE` and either side can be `*` to mean any, such as any base paired with USDT. Symbols are not case-sensitive and spaces around them are ignored, so `btc/usdt` and `BTC/USDT` are the same instrument.
+     * The instruments the run reads. For a run started with a list, that list as sent; for one started without `instruments`, or with `["*"]`, what the start resolved: the list of pairs the compilation of the strategy records as the instruments it accepts, when it records one, or `["*"]` for every instrument the exchange/segment offers (tier-gated). An entry is written `BASE/QUOTE` and either side can be `*` to mean any, such as any base paired with USDT. Symbols are not case-sensitive and spaces around them are ignored, so `btc/usdt` and `BTC/USDT` are the same instrument. A `dex` source holds exactly one entry, the address of its pool.
      */
     instruments: Array<string>;
 };
@@ -1747,17 +1977,23 @@ type LiveSource = {
  */
 type LiveSourceRequest = {
     /**
-     * Venue category. `cx` (centralized exchange) is the only one live runs support today.
+     * Venue category. `cex` is a centralized exchange and `dex` is one pool on a decentralized exchange, which takes its own `exchange`, `segment`, `type` and `instruments` (see "Sources" in the Live execution guide). `cx` and `dx`, the spellings used before, are still read as `cex` and `dex`; the run always reports the new ones.
+     */
+    venueType: "cex" | "dex";
+    /**
+     * The exchange id, as `GET /exchanges` lists it. For a `dex` source, the chain the pool is on; `robinhood` is the only one today.
      */
-    venueType: string;
     exchange: string;
+    /**
+     * The segment, as `GET /exchanges` lists it for that exchange, among its `liveSegments` (a segment with no live data is refused with `400`). For a `cex` source, the market segment (`spot` today); for a `dex` source, the protocol of the pool, `uniswap-v3` the only one today.
+     */
     segment: string;
     /**
-     * Both `ticker` and `kline` connect to the lightest (fastest) cadence available for the exchange — today, 1 tick/second on every supported exchange. Choosing a specific cadence is not offered yet.
+     * Both `ticker` and `kline` connect to the lightest (fastest) cadence available for the exchange — today, 1 tick/second on every supported exchange. Choosing a specific cadence is not offered yet. A `dex` source supports only `kline`: one candle per second of the pool's trades.
      */
     type: "ticker" | "kline";
     /**
-     * Which instruments the run reads. A QTScript strategy can declare which instruments it accepts with an `instruments` line in its source. When the compilation of the strategy records that selection as a list of pairs, leaving `instruments` out, or sending `["*"]`, takes that list; otherwise the run reads every instrument the exchange/segment offers. A list of instruments is taken as sent, and `[]` and `null` are refused with `400`. An entry is written `BASE/QUOTE`; either side can be `*` to mean any: any base can be paired with USDT, and BTC can be paired with any quote. Entries are not case-sensitive and spaces around them are ignored, so `btc/usdt` and `BTC/USDT` are the same instrument. An entry that is not of that form (no `/`, an empty side, a `.` or a space inside a side, or a `*` mixed with other characters of a side) makes the run fail when it starts. Plan limits: a list with an entry that has a `*` on a side counts like `["*"]` and only plans that include the wildcard accept it; the other entries are counted one by one. The instruments the run actually reads come back in the run's `sources`.
+     * Which instruments the run reads. A QTScript strategy can declare which instruments it accepts with an `instruments` line in its source. When the compilation of the strategy records that selection as a list of pairs, leaving `instruments` out, or sending `["*"]`, takes that list; otherwise the run reads every instrument the exchange/segment offers. A list of instruments is taken as sent, and `[]` and `null` are refused with `400`. An entry is written `BASE/QUOTE`; either side can be `*` to mean any: any base can be paired with USDT, and BTC can be paired with any quote. Entries are not case-sensitive and spaces around them are ignored, so `btc/usdt` and `BTC/USDT` are the same instrument. An entry that is not of that form (no `/`, an empty side, a `.` or a space inside a side, or a `*` mixed with other characters of a side) makes the run fail when it starts. Plan limits: a list with an entry that has a `*` on a side counts like `["*"]` and only plans that include the wildcard accept it; the other entries are counted one by one. The instruments the run actually reads come back in the run's `sources`. A `dex` source needs exactly one entry, the address of its pool (`0x` and 40 hexadecimal digits, not case-sensitive): it cannot be left out and `*` is not accepted.
      */
     instruments?: Array<string>;
 };
@@ -1770,13 +2006,22 @@ type StartLiveRequest = {
         [key: string]: unknown;
     };
     /**
-     * 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.
+     * A `public` run appears in `GET /live/public` and its signal channel accepts subscriptions from anyone, not only you — from the moment it is in the `live` stage, which is when it is promoted or, for a run that starts there, at once. 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, from its first signal — in the `sandbox` stage too, where only you can subscribe to it. See the "Live execution" guide.
      */
     relay?: boolean;
+    /**
+     * Start in the `sandbox` stage even though an earlier run of yours already took this compiled strategy
+     * through it. Without it, such a strategy starts in `LIVE` at once; with `true` it starts in `SANDBOX` like
+     * a first run, which is how to read its signals back over the connection (`history`, kept for the
+     * `sandbox` stage only) while you debug it. For a strategy that has not been through the sandbox it
+     * changes nothing: it always starts there. Anything other than `true` or `false` is `400`.
+     *
+     */
+    sandbox?: 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
@@ -1883,7 +2128,7 @@ type LiveRun = {
     description?: string;
     visibility: "private" | "public";
     /**
-     * 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.
+     * A new run 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. A run of a strategy that an earlier run of yours already took through the trial starts `LIVE`, unless you started it with `sandbox: true`.
      */
     stage: "SANDBOX" | "LIVE";
     /**
@@ -1899,12 +2144,15 @@ type LiveRun = {
      * 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:
+     * definition was refused, the pool address of a `dex` run is not a pool of its protocol on its chain,
+     * the platform has no room to follow the pool of a `dex` run, 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.
+     * live-run limit) until then; one that cannot run, and will not by waiting, because its strategy cannot
+     * consume its source type or because the pool of a `dex` run is not a pool or has no room to be followed,
+     * is stopped by the platform itself (`desired: STOPPED`), so it holds no place.
      *
      */
     reason?: string;
@@ -1925,7 +2173,7 @@ type LiveRun = {
      */
     startedAtMs: number;
     /**
-     * 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.
+     * 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. A run that started in `LIVE` without a trial has it from the start: the verdict of the earlier run it relies on, with `inheritedFrom` naming that run. `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;
@@ -2057,7 +2305,7 @@ type LiveRunSummary = {
     description?: string;
     visibility: "private" | "public";
     /**
-     * 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.
+     * A new run 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. A run of a strategy that an earlier run of yours already took through the trial starts `LIVE`, unless you started it with `sandbox: true`.
      */
     stage: "SANDBOX" | "LIVE";
     /**
@@ -2073,12 +2321,15 @@ type LiveRunSummary = {
      * 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:
+     * definition was refused, the pool address of a `dex` run is not a pool of its protocol on its chain,
+     * the platform has no room to follow the pool of a `dex` run, 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.
+     * live-run limit) until then; one that cannot run, and will not by waiting, because its strategy cannot
+     * consume its source type or because the pool of a `dex` run is not a pool or has no room to be followed,
+     * is stopped by the platform itself (`desired: STOPPED`), so it holds no place.
      *
      */
     reason?: string;
@@ -2343,6 +2594,10 @@ type AuthenticateErrors = {
      * API key is invalid, revoked, or expired.
      */
     401: AuthTokenError;
+    /**
+     * The API key is valid but carries no scopes, and this deployment requires them.
+     */
+    403: AuthTokenError;
     /**
      * Rate limit exceeded for this API key.
      */
@@ -2408,16 +2663,20 @@ type ListInstrumentsData = {
 };
 type ListInstrumentsErrors = {
     /**
-     * Exchange not found or instrument catalog not available
+     * The exchange is not one `GET /exchanges` lists
+     */
+    400: ResponseError;
+    /**
+     * The instrument catalog is not available
      */
     404: ResponseError;
 };
 type ListInstrumentsError = ListInstrumentsErrors[keyof ListInstrumentsErrors];
 type ListInstrumentsResponses = {
     /**
-     * The default (spot) segment's instruments in `data`, `meta`, and HAL `_links` (self + spot/futures segment discovery)
+     * The default (spot) segment's instruments in `data`, `meta`, and HAL `_links` (self + spot/futures segment discovery); for a decentralized exchange, its pools
      */
-    200: InstrumentListResponse;
+    200: InstrumentCatalogueResponse;
 };
 type ListInstrumentsResponse = ListInstrumentsResponses[keyof ListInstrumentsResponses];
 type ListSegmentInstrumentsData = {
@@ -2428,16 +2687,20 @@ type ListSegmentInstrumentsData = {
          */
         exchangeId: string;
         /**
-         * Market segment to list instruments for
+         * The segment to list instruments for, one of the exchange's `segments` in `GET /exchanges`; `spot` or `futures` for a centralized exchange, a protocol (`uniswap-v3`) for a decentralized one
          */
-        segment: "spot" | "futures";
+        segment: string;
     };
     query?: never;
     url: "/exchange/{exchangeId}/{segment}/instruments";
 };
 type ListSegmentInstrumentsErrors = {
     /**
-     * Exchange, segment, or instrument catalog not found
+     * The exchange is not one `GET /exchanges` lists, or the segment is not one the exchange has (`spot` or `futures` for a centralized exchange, a protocol for a decentralized one)
+     */
+    400: ResponseError;
+    /**
+     * The instrument catalog is not available
      */
     404: ResponseError;
 };
@@ -2446,7 +2709,7 @@ type ListSegmentInstrumentsResponses = {
     /**
      * An object with a `data` array of instrument details (each with per-data-type coverage) and a `meta` block
      */
-    200: InstrumentListResponse;
+    200: InstrumentCatalogueResponse;
 };
 type ListSegmentInstrumentsResponse = ListSegmentInstrumentsResponses[keyof ListSegmentInstrumentsResponses];
 type DownloadTickersData = {
@@ -2484,25 +2747,38 @@ type DownloadTickersData = {
 };
 type DownloadTickersErrors = {
     /**
-     * Missing or malformed parameters (e.g. `hour` not `YYYY-MM-DDTHH`).
+     * Missing or malformed parameters (e.g. `hour` not `YYYY-MM-DDTHH`), an `hour` in the
+     * future, or an hour older than the last 7 days (`reason: OUTSIDE_WINDOW`, with `next`).
+     *
      */
     400: ResponseError;
     /**
-     * No Lastra segment exists for the requested instrument/hour.
+     * No segment for the requested instrument/hour. `reason: NOT_YET_AVAILABLE` — the hour
+     * is not stored yet and no provisional answer was given for it (the answer carries
+     * `Retry-After`); `reason: NO_DATA` — the hour is stored and holds nothing for this
+     * instrument.
+     *
      */
     404: ResponseError;
     /**
      * Unexpected I/O error serving the file.
      */
     500: ResponseError;
+    /**
+     * Reads are being limited (of stored or of provisional data) and this one was not served
+     * (`reason: TEMPORARILY_UNAVAILABLE`). Ask again after the `Retry-After` delay.
+     *
+     */
+    503: ResponseError;
 };
 type DownloadTickersError = DownloadTickersErrors[keyof DownloadTickersErrors];
 type DownloadTickersResponses = {
     /**
      * One hour of tickers for the instrument. `Content-Type` is
-     * `application/vnd.lastra` by default or
+     * `application/vnd.qtsurfer.lastra` by default or
      * `application/vnd.apache.parquet` when `format=parquet` was
-     * requested.
+     * requested. The hour in progress, or one that has ended and is not stored yet, may be
+     * provisional where the service gives provisional answers: see `X-Data-Status`.
      *
      */
     200: Blob | File;
@@ -2542,24 +2818,38 @@ type DownloadKlinesData = {
 };
 type DownloadKlinesErrors = {
     /**
-     * Missing or malformed parameters (e.g. `hour` not `YYYY-MM-DDTHH`).
+     * Missing or malformed parameters (e.g. `hour` not `YYYY-MM-DDTHH`), an `hour` in the
+     * future, or an hour older than the last 7 days (`reason: OUTSIDE_WINDOW`, with `next`).
+     *
      */
     400: ResponseError;
     /**
-     * No Lastra segment exists for the requested instrument/hour.
+     * No segment for the requested instrument/hour. `reason: NOT_YET_AVAILABLE` — the hour
+     * is not stored yet and no provisional answer was given for it (the answer carries
+     * `Retry-After`); `reason: NO_DATA` — the hour is stored and holds nothing for this
+     * instrument.
+     *
      */
     404: ResponseError;
     /**
      * Unexpected I/O error serving the file.
      */
     500: ResponseError;
+    /**
+     * Reads are being limited (of stored or of provisional data) and this one was not served
+     * (`reason: TEMPORARILY_UNAVAILABLE`). Ask again after the `Retry-After` delay.
+     *
+     */
+    503: ResponseError;
 };
 type DownloadKlinesError = DownloadKlinesErrors[keyof DownloadKlinesErrors];
 type DownloadKlinesResponses = {
     /**
      * One hour of klines for the instrument. `Content-Type` is
-     * `application/vnd.lastra` by default or
-     * `application/vnd.apache.parquet` when `format=parquet`.
+     * `application/vnd.qtsurfer.lastra` by default or
+     * `application/vnd.apache.parquet` when `format=parquet` was
+     * requested. The hour in progress, or one that has ended and is not stored yet, may be
+     * provisional where the service gives provisional answers: see `X-Data-Status`.
      *
      */
     200: Blob | File;
@@ -3439,6 +3729,15 @@ type ImportDatasetErrors = {
      * `cadence`, whether that combination is actually servable on the requested `network` —
      * is checked later, asynchronously — see the `failed` status on the poll endpoint below.
      *
+     * For `type: cex`: no `cex` block, or its `exchange` is not a centralized exchange of
+     * `GET /exchanges` (a decentralized one is `400` too — use `type: dex`), `segment` is not
+     * `spot` (the only segment a `cex` import takes today), `dataType` is not `ticker` or
+     * `klines`, or
+     * `cadence` is not one of the values a `cex` import takes (see `DatasetImportRequest`).
+     * Whether the range holds data, and whether it holds data fine enough for the `cadence`
+     * asked, is checked later, asynchronously — see the `failed` status on the poll endpoint
+     * below.
+     *
      */
     400: ResponseError;
     /**
@@ -3554,7 +3853,7 @@ type StartLiveData = {
 };
 type StartLiveErrors = {
     /**
-     * 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. A `warmFrom` that is not an integer from 0 to 3600. An `instruments` that is empty or `null`.
+     * Malformed `sources` (not exactly one entry, missing field, unsupported `type`), a `venueType`, `exchange` and `segment` that `GET /exchanges` does not list together, or a segment with no live data (the message names what it lists), 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. A `warmFrom` that is not an integer from 0 to 3600. An `instruments` that is empty or `null`.
      */
     400: ResponseError;
     /**
@@ -3577,7 +3876,7 @@ type StartLiveErrors = {
 type StartLiveError = StartLiveErrors[keyof StartLiveErrors];
 type StartLiveResponses = {
     /**
-     * Started — the run's own state, in the sandbox stage, with its `streamUrl` when you asked for a stream
+     * Started — the run's own state, in the sandbox stage (in the live stage for a strategy that has already been through the sandbox), with its `streamUrl` when you asked for a stream
      */
     201: LiveRunWithStream;
 };
@@ -3986,6 +4285,10 @@ type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean
  * expires after `expires_in` seconds. Callers should refresh the token
  * before expiry (or on a `401` response) by calling this endpoint again.
  *
+ * The answer's `scopes` say what the key may do. Where a deployment requires scopes, a key
+ * that carries none is refused with `403` and the code `apikey_without_scopes`: create a key
+ * with at least one scope.
+ *
  */
 declare const authenticate: <ThrowOnError extends boolean = false>(options?: Options<AuthenticateData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AuthTokenResponse, unknown, ThrowOnError>;
 /**
@@ -4008,6 +4311,18 @@ declare const getAccount: <ThrowOnError extends boolean = false>(options?: Optio
 declare const getAccountUsage: <ThrowOnError extends boolean = false>(options?: Options<GetAccountUsageData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AccountUsage, unknown, ThrowOnError>;
 /**
  * List the available exchanges
+ * The exchanges the platform knows, centralized and decentralized, each with its `venueType` and the
+ * `segments` it offers. Ids, venue types and segments are lower-case, and are written the same way
+ * wherever the API takes them: `/exchange/binance/spot/instruments`, and the `exchange`, `venueType`
+ * and `segment` of a live run's source.
+ *
+ * `venueType` is `cex` for a centralized exchange and `dex` for a decentralized one. The `segments` of a
+ * `cex` exchange are the market segments its instrument catalogues are served under (`spot`, `futures`);
+ * its `liveSegments`, among them, are those a live run can read, because live data is published for them.
+ * A `dex` exchange has no market data to prepare or backtest, so its id is `400` in the routes that take an
+ * `exchangeId`, except the two instruments routes: its `segments` are the protocols whose pools a run can
+ * read, and those routes list the pools, since the instrument of a run on it is a pool's address.
+ *
  */
 declare const listExchanges: <ThrowOnError extends boolean = false>(options?: Options<ListExchangesData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<Exchange[], unknown, ThrowOnError>;
 /**
@@ -4017,8 +4332,12 @@ declare const listExchanges: <ThrowOnError extends boolean = false>(options?: Op
  * confirms the served `segment` (`spot`); HAL `_links` carry `self` plus the
  * `spot` / `futures` segment-discovery links.
  *
+ * For a decentralized exchange (`venueType` `dex` in `GET /exchanges`) the instruments are its pools,
+ * each a `PoolDetail`, and the default segment is the first one the exchange lists (`uniswap-v3` for
+ * `robinhood`).
+ *
  */
-declare const listInstruments: <ThrowOnError extends boolean = false>(options: Options<ListInstrumentsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<InstrumentListResponse, ResponseError, ThrowOnError>;
+declare const listInstruments: <ThrowOnError extends boolean = false>(options: Options<ListInstrumentsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<InstrumentCatalogueResponse, ResponseError, ThrowOnError>;
 /**
  * List an exchange segment's instruments
  * Returns the instruments for one market segment of the exchange, each with
@@ -4026,8 +4345,13 @@ declare const listInstruments: <ThrowOnError extends boolean = false>(options: O
  * `spot` / `futures` segment-discovery links; the default-segment shortcut is
  * `GET /exchange/{exchangeId}/instruments` (spot).
  *
+ * For a decentralized exchange the segments are its protocols (`uniswap-v3` for `robinhood`) and the
+ * instruments are its pools, each a `PoolDetail`: the 50 with most volume in the last 24 hours among
+ * those with at least 10,000 US dollars of liquidity, refreshed every hour. The list is a place to
+ * start, not the whole market: a live run can read any pool of the protocol, listed or not.
+ *
  */
-declare const listSegmentInstruments: <ThrowOnError extends boolean = false>(options: Options<ListSegmentInstrumentsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<InstrumentListResponse, ResponseError, ThrowOnError>;
+declare const listSegmentInstruments: <ThrowOnError extends boolean = false>(options: Options<ListSegmentInstrumentsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<InstrumentCatalogueResponse, ResponseError, ThrowOnError>;
 /**
  * Download one hour of tickers for an instrument as a Lastra segment
  * Serves exactly one hour of raw ticker data for the given instrument on the
@@ -4037,9 +4361,33 @@ declare const listSegmentInstruments: <ThrowOnError extends boolean = false>(opt
  *
  * One segment = one hour, aligned to UTC. The `hour` query parameter selects
  * the segment and must match `YYYY-MM-DDTHH` (no minutes/seconds, no timezone
- * suffix). Example: `hour=2026-01-15T10` returns `h10.lastra` for
- * 2026-01-15, covering `[10:00:00Z, 11:00:00Z)`. Hours not yet available
- * return `404`.
+ * suffix). Example: `hour=2026-10-15T10` is the segment `h10.lastra` of
+ * 2026-10-15, covering `[10:00:00Z, 11:00:00Z)`. The hour has to be one of the last 7 days (see
+ * below): read the example as the shape of the value.
+ *
+ * **Which hours.** The last 7 days: an hour that started no more than 7 days before the
+ * request and has ended. This route gives one hour of one instrument, fast; it is not how to
+ * get older history or a range. An older hour is `400` with `reason: OUTSIDE_WINDOW`, and the
+ * error carries `next`, the `POST /datasets/imports` request that imports exactly that hour
+ * as a dataset (add a `name`); a longer span is imported the same way, within your plan's
+ * limits.
+ *
+ * **The hour in progress and the last hours.** The hour in progress, and an hour that has ended
+ * but is not stored yet, can be answered with what has been received so far, marked provisional:
+ * `200` with `X-Data-Status: provisional` and `X-Data-Through`, the instant of the last row.
+ * Not every deployment of the service gives provisional answers: where it does not, those hours
+ * are `404` with `reason: NOT_YET_AVAILABLE` and a `Retry-After`, and a client that needs them
+ * handles both. A provisional answer is not to keep: it can still grow, and the stored hour
+ * replaces it once there is one. It takes seconds to build, longer the further the hour has gone,
+ * and the service limits how many it builds at once (`503` with `Retry-After`). When there is
+ * nothing to give, because the instrument has no rows in the hour yet or what has been received
+ * does not reach back to the start of the hour, the answer is also `404` with
+ * `reason: NOT_YET_AVAILABLE`.
+ *
+ * **Timestamps.** In a Lastra response the `ts` column holds microseconds since the epoch,
+ * declared by `ts_unit: micros` in the column's metadata and by the response header
+ * `X-Ts-Unit: micros`. In a Parquet response the timestamp column is a `TIMESTAMP` in
+ * milliseconds.
  *
  * A `format=parquet` query parameter switches the response to on-the-fly
  * Parquet conversion via [lastra-convert](https://github.com/QTSurfer/lastra-convert)
@@ -4072,6 +4420,9 @@ declare const downloadTickers: <ThrowOnError extends boolean = false>(options: O
  * format read the other with the same code. Use this endpoint when a
  * per-tick payload would be too large for the window of interest.
  *
+ * The hours served (the last 7 days; the hour in progress and the last hours may be provisional), the timestamps
+ * (`ts` in microseconds, `X-Ts-Unit: micros`) and the errors are those of the tickers route.
+ *
  */
 declare const downloadKlines: <ThrowOnError extends boolean = false>(options: Options<DownloadKlinesData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<Blob | File, ResponseError, ThrowOnError>;
 /**
@@ -4522,8 +4873,18 @@ declare const getDatasetUpload: <ThrowOnError extends boolean = false>(options:
  * as a dataset version indistinguishable from an uploaded one once it's ready. Poll
  * `GET /datasets/{datasetId}/imports/{importId}` for progress.
  *
- * `type` selects the source. `dex` — history over a pool/pair's own on-chain market — is the
- * only value today; other source types join this same endpoint later.
+ * `type` selects the kind of venue the history comes from, with the same two values as the
+ * `venueType` of `GET /exchanges`: `dex` — history over a pool/pair's own on-chain market —
+ * and `cex` — the history of a centralized exchange's market, kept by the platform. Each
+ * has its own block (`dex`, `cex`). The exchange id of a `cex` import has to be a centralized
+ * exchange of `GET /exchanges`; a decentralized one (`robinhood`, say) is `400`, and is imported
+ * with `type: dex`.
+ *
+ * A `cex` import covers one instrument over a range: the API reads that range of the
+ * exchange's history, builds the bars of the requested `cadence` from the finest data it has
+ * for it, and stores the result as a dataset version, exactly as for an upload. `cex.dataType`
+ * picks tickers or klines and is also the resulting dataset's `type`. The range is capped by
+ * your tier like any import (`maxImportRangeHours` of `GET /account`).
  *
  * A `dex` import has two data shapes, chosen by the top-level `cadence`:
  *
@@ -4573,13 +4934,23 @@ declare const stopLive: <ThrowOnError extends boolean = false>(options: Options<
 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**
+ * Starts your strategy against a live market feed. A new run begins in the **sandbox**
  * stage — a short trial that compares an independent second execution against the first for
  * agreement — before it is eligible for promotion to the live stage where it actually
  * publishes signals other systems can act on. Poll `GET /strategy/{strategyId}/live` (or
  * `PATCH`/`DELETE` `/live/{runId}` once you have the `runId`) to watch `stage` move from
  * `SANDBOX` to `LIVE`.
  *
+ * A strategy that has already been through that trial does not go through it again. When an
+ * earlier run of yours of the same compiled strategy was promoted to `LIVE`, and none of that
+ * compilation's runs was stopped for using more resources than allowed, the new run starts in
+ * `LIVE` at once: the response says `stage: LIVE` and carries the earlier verdict in `gate`.
+ * The parameters, sources and instruments may differ from the earlier run. Submitting the
+ * strategy again (`POST /strategy`) compiles it anew, and a new compilation goes through the
+ * sandbox like a first run. Send `sandbox: true` to start in the sandbox anyway — for
+ * example to read the run's signals back over the connection while you debug it, which the
+ * live stage does not keep.
+ *
  * Only one run per strategy at a time — starting again while one is already running is `409`;
  * stop the current one first.
  *
@@ -4588,7 +4959,16 @@ declare const getLive: <ThrowOnError extends boolean = false>(options: Options<G
  * (fastest) cadence available for the exchange — today that is 1 tick/second on every
  * supported exchange; choosing among several cadences is not offered yet.
  *
- * `instruments` can be left out. A QTScript strategy can declare which instruments it accepts with an `instruments`
+ * `venueType` is `cex` (a centralized exchange) or `dex` (one pool on a decentralized exchange). A `dex` source reads one
+ * pool, takes only `kline`, and needs the pool's address as its single instrument. See the "Live execution" guide,
+ * "Sources".
+ *
+ * `venueType`, `exchange` and `segment` have to be ones `GET /exchanges` lists together: the exchange under that
+ * venue type, and the segment among its `liveSegments`. Case and the spaces around a value do not matter, and the
+ * run reports them back in lower case (`cx`, the older spelling of `cex`, is still read). Anything else is refused
+ * with `400`, naming what the list has.
+ *
+ * `instruments` can be left out, except for a `dex` source. A QTScript strategy can declare which instruments it accepts with an `instruments`
  * line in its source; when the compilation of the strategy records that selection as a list of pairs, a
  * start that leaves `instruments` out, or sends `["*"]`, takes that list, and otherwise the run reads every
  * instrument the exchange/segment offers. A list you send is taken as sent. Either side of an entry can be `*`
@@ -4801,4 +5181,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 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 LiveSourceRequest, 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, type WarmFrom, 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 };
+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 DatasetImportCexRequest, 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 ErrorNextCall, 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 InstrumentCatalogueResponse, type InstrumentCoverage, type InstrumentDetail, type InstrumentLinks, type InstrumentListMeta, type InstrumentListResponse, type JobState, type KeyScopes, 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 LiveSourceRequest, 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 PoolDetail, type PoolLinks, type PoolListMeta, type PoolListResponse, 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, type WarmFrom, 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 };