@qtsurfer/api-client 0.15.0 → 0.17.0

package/dist/index.d.ts

@@ -96,6 +96,107 @@ type HalLink = {
      */
     templated?: boolean;
 };
+/**
+ * Your identity and tier limits. No database call behind this one — safe to fetch on every
+ * page load. Live usage against these limits is a separate resource, `GET /account/usage`,
+ * deliberately: usage changes on every upload/execution and costs a query to compute, this
+ * one doesn't.
+ *
+ */
+type Account = {
+    /**
+     * Your account id — the JWT `sub` claim.
+     */
+    userId: string;
+    /**
+     * Your current subscription tier.
+     */
+    tier: string;
+    /**
+     * Maximum number of active datasets your tier allows.
+     */
+    maxDatasets: number;
+    /**
+     * Maximum size, in bytes, of a single dataset version.
+     */
+    maxDatasetBytes: number;
+    /**
+     * Maximum combined storage, in bytes, across every dataset, strategy-execution signal,
+     * and registered strategy on your account — one shared pool, not a separate cap per
+     * resource type, since they all compete for the same underlying storage. See `GET
+     * /account/usage`'s `storageBytesUsed` for your current usage against this number.
+     *
+     */
+    maxTotalStorageBytes: number;
+    _links: AccountLinks;
+};
+/**
+ * HAL `_links` for `GET /account`
+ */
+type AccountLinks = {
+    /**
+     * Link to this resource.
+     */
+    self: HalLink;
+    /**
+     * Link to your live usage, `GET /account/usage`.
+     */
+    usage: HalLink;
+};
+/**
+ * Your live usage of the shared storage pool `GET /account`'s `maxTotalStorageBytes` caps.
+ * Not guaranteed real-time — a just-completed upload or strategy execution may take a short
+ * moment to be reflected here.
+ *
+ */
+type AccountUsage = {
+    /**
+     * Active datasets counted — the same set `GET /account`'s `maxDatasets` limits.
+     */
+    datasetsUsed: number;
+    /**
+     * Combined bytes of every active dataset's current version.
+     */
+    datasetBytesUsed: number;
+    /**
+     * Recorded strategy-execution signal uploads.
+     */
+    signalsUsed: number;
+    /**
+     * Combined bytes of every recorded signal upload.
+     */
+    signalBytesUsed: number;
+    /**
+     * Registered strategies (see `GET /strategies`).
+     */
+    strategiesUsed: number;
+    /**
+     * Combined bytes of each registered strategy's source plus its latest compiled
+     * bytecode. Superseded (non-latest) compilations aren't counted.
+     *
+     */
+    strategyBytesUsed: number;
+    /**
+     * `datasetBytesUsed + signalBytesUsed + strategyBytesUsed` — the number checked
+     * against `GET /account`'s `maxTotalStorageBytes`.
+     *
+     */
+    storageBytesUsed: number;
+    _links: AccountUsageLinks;
+};
+/**
+ * HAL `_links` for `GET /account/usage`
+ */
+type AccountUsageLinks = {
+    /**
+     * Link to this resource.
+     */
+    self: HalLink;
+    /**
+     * Link to your tier limits, `GET /account`.
+     */
+    account: HalLink;
+};
 /**
  * Exchange instrument with per-data-type coverage and market info
  */
@@ -171,8 +272,17 @@ type Exchange = {
 };
 /**
  * Managed exchange data sources available for backtesting.
+ *
+ * * `ticker` — trades. Can be prepared, executed and swept.
+ * * `kline` — aggregated bars (candlesticks). Can be prepared, executed and swept. A run reads
+ * bars of the `cadence` the data was prepared at: you choose the bar width when you prepare,
+ * and the strategy does not fix it. See `PrepareRequest.cadence` for the accepted values.
+ * * `funding` — funding rates. Can be **prepared but not executed or swept yet**: a `funding`
+ * request to `execute` or `executeSweep` is rejected with `400` before anything is queued,
+ * and the message names the sources that can be run.
+ *
  */
-type DataSourceType = "ticker";
+type DataSourceType = "ticker" | "kline" | "funding";
 /**
  * Two shapes, chosen by the `exchangeId` path segment. Against a managed exchange,
  * `instrument` is required and `datasetId`/`datasetVersionId` are ignored. Against the
@@ -221,9 +331,14 @@ type PrepareRequest = {
      * than the source, or not an exact multiple of it, returns `400`. What's accepted, and
      * what omitting it means, depends on the source:
      *
-     * * Managed exchange — 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, `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.
      * * 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
@@ -944,8 +1059,9 @@ type EquityCurveResult = {
 };
 /**
  * Unique identifier for a compiled strategy, derived from the source itself: the same code
- * always yields the same id, for every caller, whatever its formatting. See
- * `POST /strategy` for exactly which rewrites preserve it and which do not.
+ * always yields the same id, for every caller. How much formatting the id ignores depends on
+ * the language — see `POST /strategy` for exactly which rewrites preserve it and which do
+ * not.
  *
  */
 type StrategyId = string;
@@ -1117,9 +1233,10 @@ type StrategyState = {
  * A dataset's own metadata — not its data. `currentVersionId` is what a prepare against
  * `exchangeId: user` reads by default; see `DatasetVersion` for what a version carries.
  *
- * `from`/`to`/`cadence` mirror that current version's own discovered range and cadence, so
- * you don't need a second call to `GET /datasets/{datasetId}/uploads/{uploadId}` just to see
- * what a dataset covers. Absent until a version exists.
+ * `from`/`to`/`cadence`/`timestampUnit`/`bytes`/`rows`/`gaps`/`largestGapSteps` mirror that
+ * current version's own discovered range, cadence, timestamp unit and metrics, so you don't
+ * need a second call to `GET /datasets/{datasetId}/uploads/{uploadId}` just to see what a
+ * dataset covers.
  *
  */
 type Dataset = {
@@ -1171,6 +1288,47 @@ type Dataset = {
      *
      */
     cadence?: string;
+    /**
+     * `currentVersionId`'s own timestamp unit (see `DatasetVersion.timestampUnit`) — decode
+     * the `timestamp` column of `dataUrl`'s file accordingly. Present only when `status` is
+     * `ready`.
+     *
+     */
+    timestampUnit?: "iso" | "s" | "ms" | "us";
+    /**
+     * * `ready` — `currentVersionId` is set; `from`/`to`/`cadence`/`bytes`/`rows`/`gaps`/
+     * `largestGapSteps` describe it.
+     * * `failed` — the most recent upload/import attempt failed. `currentVersionId` and the
+     * fields above are absent — there is nothing to read yet. See `error`.
+     * * `pending` — nothing has ever been attempted (just created, or an upload was never
+     * finalized).
+     *
+     */
+    status: "ready" | "failed" | "pending";
+    /**
+     * Size of `currentVersionId`'s own stored file. Present only when `status` is `ready` —
+     * see `DatasetVersion.bytes` for what it measures exactly.
+     *
+     */
+    bytes?: number;
+    /**
+     * `currentVersionId`'s own row count. Present only when `status` is `ready`.
+     */
+    rows?: number;
+    /**
+     * `currentVersionId`'s own gap count at its discovered cadence. Present only when `status` is `ready`.
+     */
+    gaps?: number;
+    /**
+     * `currentVersionId`'s own largest gap, in units of its discovered cadence step. Present only when `status` is `ready`.
+     */
+    largestGapSteps?: number;
+    /**
+     * A human-readable reason the most recent upload/import attempt failed. Present only
+     * when `status` is `failed`.
+     *
+     */
+    error?: string;
 };
 /**
  * A `Dataset` plus a self link. Returned by `GET /datasets/{datasetId}`.
@@ -1188,8 +1346,9 @@ type DatasetWithLinks = Dataset & {
     /**
      * Which format `dataUrl` is actually in — check this rather than assuming it
      * matches how you uploaded it. `lastra` — our native columnar format — for a CSV (or
-     * gzip/zip of one) upload, always converted on ingest. `parquet` for a parquet
-     * upload, stored as-is today.
+     * gzip/zip of one) upload, always converted on ingest, or for a lastra upload,
+     * stored as-is (the value alone doesn't tell you which). `parquet` for a parquet
+     * upload, also stored as-is today.
      *
      */
     dataFormat?: "lastra" | "parquet";
@@ -1306,8 +1465,9 @@ type DatasetVersion = {
     /**
      * Which format `dataUrl` is actually in — check this rather than assuming it matches
      * how you uploaded it. `lastra` — our native columnar format — for a CSV (or gzip/zip
-     * of one) upload, always converted on ingest. `parquet` for a parquet upload, stored
-     * as-is today.
+     * of one) upload, always converted on ingest, or for a lastra upload, stored as-is
+     * (the value alone doesn't tell you which). `parquet` for a parquet upload, also
+     * stored as-is today.
      *
      */
     dataFormat?: "lastra" | "parquet";
@@ -1518,6 +1678,239 @@ type AuthTokenError = {
      */
     message: string;
 };
+/**
+ * One market feed a live run consumes. Exactly one entry per run today.
+ */
+type LiveSource = {
+    /**
+     * Venue category. `cx` (centralized exchange) is the only one live runs support today.
+     */
+    venueType: string;
+    exchange: string;
+    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.
+     */
+    type: "ticker" | "kline";
+    /**
+     * Instrument symbols, or `["*"]` for every instrument the exchange/segment offers (tier-gated).
+     */
+    instruments: Array<string>;
+};
+type StartLiveRequest = {
+    sources: [LiveSource];
+    /**
+     * Strategy parameters to start with. Opaque key/value pairs — see this strategy's own `declaredProperties` (from `POST /strategy`) for the keys it accepts.
+     */
+    params?: {
+        [key: string]: unknown;
+    };
+    /**
+     * A `public` run appears in `GET /live/public` and its signal channel accepts subscriptions from anyone, not only you.
+     */
+    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.
+     */
+    relay?: boolean;
+    name?: string;
+    description?: string;
+};
+type UpdateLiveRequest = {
+    visibility?: "private" | "public";
+    name?: string;
+    description?: string;
+};
+type UpdateLiveParamsRequest = {
+    /**
+     * Must be non-empty; every key must be a property your strategy declares.
+     */
+    params: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * A live run's full state, as returned by starting, reading, or stopping it through its strategy.
+ */
+type LiveRun = {
+    strategyId: StrategyId;
+    /**
+     * This run's own id — its canonical identity for `PATCH`/`PUT .../params` and for `GET /live/public`.
+     */
+    runId: string;
+    name?: string;
+    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.
+     */
+    stage: "SANDBOX" | "LIVE";
+    /**
+     * `STARTING` until first observed running; otherwise the runner's own reported state (e.g. `RUNNING`).
+     */
+    state: string;
+    /**
+     * What you last asked for. `state` can lag this briefly after `DELETE`.
+     */
+    desired: "RUNNING" | "STOPPED";
+    /**
+     * Present only when the run stopped because it exceeded its resource allowance.
+     */
+    reason?: string;
+    sources: Array<LiveSource>;
+    params: {
+        [key: string]: unknown;
+    };
+    /**
+     * Increments on every accepted `PUT .../params` call, including one that resends the current values.
+     */
+    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`.
+     */
+    relay: boolean;
+    /**
+     * Epoch milliseconds.
+     */
+    startedAtMs: number;
+    /**
+     * The sandbox trial's promotion verdict, once one exists. Shape is not yet stabilized as public API — treat as opaque diagnostics.
+     */
+    gate?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * 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.
+ */
+type LiveRunCompact = {
+    runId: string;
+    name?: string;
+    description?: string;
+    visibility: "private" | "public";
+    stage: "SANDBOX" | "LIVE";
+    state: string;
+    sources: Array<LiveSource>;
+};
+/**
+ * A run as it appears in `GET /live/public` — never reveals who owns it or which strategy it runs.
+ */
+type PublicLiveRun = {
+    runId: string;
+    name?: string;
+    description?: string;
+    sources: Array<LiveSource>;
+    state: string;
+    createdAtMs: number;
+};
+type PublicLiveListResponse = {
+    runs: Array<PublicLiveRun>;
+    _links?: PublicLiveListLinks;
+};
+/**
+ * Present only when another page exists.
+ */
+type PublicLiveListLinks = {
+    next?: PublicLiveNextLink;
+};
+type PublicLiveNextLink = {
+    href?: string;
+};
+/**
+ * One page of a run's recorded signals, oldest first.
+ */
+type LiveSignalPage = {
+    signals: Array<LiveSignal>;
+    /**
+     * The oldest moment this run's signals can still be read from. Absent when the run has produced nothing yet. It moves forward over time as older signals are discarded, so a `sinceMs` earlier than this is served from here instead.
+     */
+    availableSinceMs?: number;
+    _links?: PublicLiveListLinks;
+};
+/**
+ * One signal, in the same shape the real-time signal channel delivers.
+ */
+type LiveSignal = {
+    /**
+     * Envelope schema version.
+     */
+    v: number;
+    /**
+     * Stable id for this exact signal — dedupe on it across reconnects or overlapping reads.
+     */
+    signalId: string;
+    runId: string;
+    /**
+     * The stage the run was in when this signal was produced.
+     */
+    stage: "sandbox" | "live";
+    /**
+     * The parameter set in force when this signal was produced.
+     */
+    paramsVersion?: number;
+    type: "hint" | "info" | "marker" | "command";
+    /**
+     * `BUY`/`SELL` for a `hint`, the command name for a `command`, absent otherwise.
+     */
+    kind?: string | null;
+    /**
+     * Market time the signal was produced.
+     */
+    eventTsMs: number;
+    /**
+     * Time it was published — always at or after `eventTsMs`.
+     */
+    emittedAtMs: number;
+    instrument: LiveSignalInstrument;
+    order?: LiveSignalOrder;
+    /**
+     * The signal's own free-form payload.
+     */
+    data?: {
+        [key: string]: unknown;
+    };
+    /**
+     * `true` only for a signal republished to fill a gap in the record.
+     */
+    regenerated?: boolean;
+    /**
+     * Content hash, for checking that two independent deliveries of the same signal agree.
+     */
+    digest: string;
+};
+type LiveSignalInstrument = {
+    exchange?: string;
+    segment?: string;
+    /**
+     * Slashed form, e.g. `BTC/USDT`.
+     */
+    symbol?: string;
+};
+/**
+ * Present only for a `hint`.
+ */
+type LiveSignalOrder = {
+    orderKind?: string;
+    price?: string | null;
+    amount?: string | null;
+    stopPrice?: string | null;
+    trailPct?: string | null;
+} | null;
+type LiveConnectionToken = {
+    /**
+     * Pass as the `token` field of the WebSocket `connect` command — see the "Live execution" guide.
+     */
+    token: string;
+    expiresAtMs: number;
+};
+type LiveParamsUpdateResult = {
+    runId: string;
+    paramsVersion: number;
+    /**
+     * Epoch milliseconds — the earliest moment the new values are guaranteed to be in effect.
+     */
+    effectiveAtMs: number;
+};
 type AuthenticateData = {
     body?: never;
     path?: never;
@@ -1542,6 +1935,32 @@ type AuthenticateResponses = {
     200: AuthTokenResponse;
 };
 type AuthenticateResponse = AuthenticateResponses[keyof AuthenticateResponses];
+type GetAccountData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/account";
+};
+type GetAccountResponses = {
+    /**
+     * Your account
+     */
+    200: Account;
+};
+type GetAccountResponse = GetAccountResponses[keyof GetAccountResponses];
+type GetAccountUsageData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/account/usage";
+};
+type GetAccountUsageResponses = {
+    /**
+     * Your current usage
+     */
+    200: AccountUsage;
+};
+type GetAccountUsageResponse = GetAccountUsageResponses[keyof GetAccountUsageResponses];
 type ListExchangesData = {
     body?: never;
     path?: never;
@@ -1743,7 +2162,7 @@ type ListStrategiesResponses = {
 type ListStrategiesResponse = ListStrategiesResponses[keyof ListStrategiesResponses];
 type CompileStrategyData = {
     /**
-     * Raw strategy Java source code
+     * Raw strategy source code, Java or QTScript
      */
     body: string;
     path?: never;
@@ -1752,7 +2171,8 @@ type CompileStrategyData = {
 };
 type CompileStrategyErrors = {
     /**
-     * The source is not valid Java; the message carries the compiler diagnostics. Nothing is
+     * The source is not valid; the message carries the diagnostics — the compiler's for Java,
+     * and for QTScript `Line N, Column M:` entries against your own source. Nothing is
      * registered, so there is no id to look up afterwards.
      *
      */
@@ -1893,7 +2313,7 @@ type GetStrategyCodeResponses = {
     200: {
         strategyId: StrategyId;
         /**
-         * Raw strategy Java source code, exactly as registered.
+         * Raw strategy source code (Java or QTScript), exactly as registered.
          */
         code: string;
     };
@@ -1922,7 +2342,9 @@ type PrepareBacktestData = {
 type PrepareBacktestErrors = {
     /**
      * Invalid request or parameters. Also returned when `from` is older than the configured
-     * lookback window or `to` is in the future. For `exchangeId: user`, also returned when
+     * lookback window or `to` is in the future, or when `type` is `kline` and `cadence` is not
+     * one of the cadences kline data is available at (the message lists them). For
+     * `exchangeId: user`, also returned when
      * the dataset's current upload has not finished ingesting, or `cadence` asks for a finer
      * granularity than the dataset's own discovered cadence (or one that isn't an exact
      * multiple of it), or the requested range exceeds your tier's range limit.
@@ -2005,7 +2427,9 @@ type ExecuteSweepData = {
 };
 type ExecuteSweepErrors = {
     /**
-     * Invalid sweep specification or the expanded grid exceeds the server limit.
+     * Invalid sweep specification, a `type` that cannot be swept yet (`funding`), or the
+     * expanded grid exceeds the server limit.
+     *
      */
     400: ResponseError;
     /**
@@ -2239,7 +2663,9 @@ type ExecuteBacktestData = {
 };
 type ExecuteBacktestErrors = {
     /**
-     * Invalid request or parameters
+     * Invalid request or parameters. Also returned for a `type` that cannot be executed yet
+     * (`funding`); the message names the sources that can.
+     *
      */
     400: ResponseError;
     /**
@@ -2504,6 +2930,12 @@ type FinalizeDatasetUploadErrors = {
      * The uploaded file exceeds your tier's size limit for a dataset.
      */
     413: ResponseError;
+    /**
+     * Your account's total storage limit (`GET /account`'s `maxTotalStorageBytes`) is
+     * reached or would be exceeded. Delete a dataset to free space, or upgrade.
+     *
+     */
+    429: ResponseError;
 };
 type FinalizeDatasetUploadError = FinalizeDatasetUploadErrors[keyof FinalizeDatasetUploadErrors];
 type FinalizeDatasetUploadResponses = {
@@ -2573,7 +3005,10 @@ type ImportDatasetErrors = {
      */
     409: ResponseError;
     /**
-     * Your tier's dataset count limit is reached. Delete one, or upgrade.
+     * Your tier's dataset count limit is reached, or your account's total storage limit
+     * (`GET /account`'s `maxTotalStorageBytes`) is already reached. Delete a dataset to free
+     * a slot or space, or upgrade.
+     *
      */
     429: ResponseError;
 };
@@ -2615,6 +3050,252 @@ type GetDatasetImportResponses = {
     200: DatasetImportState;
 };
 type GetDatasetImportResponse = GetDatasetImportResponses[keyof GetDatasetImportResponses];
+type StopLiveData = {
+    body?: never;
+    path: {
+        /**
+         * The id returned by `POST /strategy`
+         */
+        strategyId: StrategyId;
+    };
+    query?: never;
+    url: "/strategy/{strategyId}/live";
+};
+type StopLiveErrors = {
+    /**
+     * You have never started a live run for this strategy.
+     */
+    404: ResponseError;
+};
+type StopLiveError = StopLiveErrors[keyof StopLiveErrors];
+type StopLiveResponses = {
+    /**
+     * Stop requested (or already stopped) — the run's current state
+     */
+    200: LiveRun;
+};
+type StopLiveResponse = StopLiveResponses[keyof StopLiveResponses];
+type GetLiveData = {
+    body?: never;
+    path: {
+        /**
+         * The id returned by `POST /strategy`
+         */
+        strategyId: StrategyId;
+    };
+    query?: never;
+    url: "/strategy/{strategyId}/live";
+};
+type GetLiveErrors = {
+    /**
+     * You have never started a live run for this strategy.
+     */
+    404: ResponseError;
+};
+type GetLiveError = GetLiveErrors[keyof GetLiveErrors];
+type GetLiveResponses = {
+    /**
+     * The run's current state
+     */
+    200: LiveRun;
+};
+type GetLiveResponse = GetLiveResponses[keyof GetLiveResponses];
+type StartLiveData = {
+    body: StartLiveRequest;
+    path: {
+        /**
+         * The id returned by `POST /strategy`
+         */
+        strategyId: StrategyId;
+    };
+    query?: never;
+    url: "/strategy/{strategyId}/live";
+};
+type StartLiveErrors = {
+    /**
+     * Malformed `sources` (not exactly one entry, missing field, unsupported `type`), or an invalid `visibility`.
+     */
+    400: ResponseError;
+    /**
+     * No such registered strategy for this user, or it has never been compiled.
+     */
+    404: ResponseError;
+    /**
+     * A run for this strategy is already active. Stop it first.
+     */
+    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.
+     *
+     */
+    429: ResponseError;
+};
+type StartLiveError = StartLiveErrors[keyof StartLiveErrors];
+type StartLiveResponses = {
+    /**
+     * Started — the run's own state, in the sandbox stage
+     */
+    201: LiveRun;
+};
+type StartLiveResponse = StartLiveResponses[keyof StartLiveResponses];
+type ListPublicLiveData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * The `runId` from a previous page's `_links.next.href`. Omit for the first page.
+         */
+        cursor?: string;
+        /**
+         * Page size. Larger values are capped, not rejected.
+         */
+        limit?: number;
+    };
+    url: "/live/public";
+};
+type ListPublicLiveErrors = {
+    /**
+     * An invalid `cursor` or `limit`.
+     */
+    400: ResponseError;
+};
+type ListPublicLiveError = ListPublicLiveErrors[keyof ListPublicLiveErrors];
+type ListPublicLiveResponses = {
+    /**
+     * A page of public runs
+     */
+    200: PublicLiveListResponse;
+};
+type ListPublicLiveResponse = ListPublicLiveResponses[keyof ListPublicLiveResponses];
+type UpdateLiveData = {
+    body?: UpdateLiveRequest;
+    path: {
+        /**
+         * The `runId` from `POST`/`GET`/`DELETE` `.../live` or from `GET /live/public`
+         */
+        runId: string;
+    };
+    query?: never;
+    url: "/live/{runId}";
+};
+type UpdateLiveErrors = {
+    /**
+     * `visibility` present but not `private`/`public`.
+     */
+    400: ResponseError;
+    /**
+     * No such run, or you do not own it — the two look identical on purpose.
+     */
+    404: ResponseError;
+};
+type UpdateLiveError = UpdateLiveErrors[keyof UpdateLiveErrors];
+type UpdateLiveResponses = {
+    /**
+     * Updated
+     */
+    200: LiveRunCompact;
+};
+type UpdateLiveResponse = UpdateLiveResponses[keyof UpdateLiveResponses];
+type UpdateLiveParamsData = {
+    body: UpdateLiveParamsRequest;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: "/live/{runId}/params";
+};
+type UpdateLiveParamsErrors = {
+    /**
+     * `params` missing, not an object, empty, or contains a key your strategy does not declare.
+     */
+    400: ResponseError;
+    /**
+     * No such run, or you do not own it.
+     */
+    404: ResponseError;
+    /**
+     * This run's compilation has no declared properties on record — recompile the strategy to enable runtime parameter updates.
+     */
+    409: ResponseError;
+};
+type UpdateLiveParamsError = UpdateLiveParamsErrors[keyof UpdateLiveParamsErrors];
+type UpdateLiveParamsResponses = {
+    /**
+     * Accepted
+     */
+    200: LiveParamsUpdateResult;
+};
+type UpdateLiveParamsResponse = UpdateLiveParamsResponses[keyof UpdateLiveParamsResponses];
+type GetLiveRunSignalsData = {
+    body?: never;
+    path: {
+        /**
+         * The run whose signals to read.
+         */
+        runId: string;
+    };
+    query?: {
+        /**
+         * Start from this moment (epoch ms). Omitted, or older than the available window, starts at `availableSinceMs`. Ignored when `cursor` is given.
+         */
+        sinceMs?: number;
+        /**
+         * Narrow to one or more instruments. Omitted, or `*`, returns every instrument the run
+         * covers. Accepts a single pair (`BTC/USDT`), either half as a wildcard (`*USDT` for any
+         * base against that quote, `BTC*` for that base against any quote), or a comma-separated
+         * list of pairs (`BTC/USDT,ETH/EUR`). Symbols are matched exactly, case included — pass
+         * them as this API reports them.
+         *
+         */
+        instrument?: string;
+        /**
+         * Continue from a previous page's `_links.next`. Takes precedence over `sinceMs`.
+         */
+        cursor?: string;
+        /**
+         * Page size.
+         */
+        limit?: number;
+    };
+    url: "/live/{runId}/signals";
+};
+type GetLiveRunSignalsErrors = {
+    /**
+     * `instrument`, `sinceMs`, `limit` or `cursor` is malformed.
+     */
+    400: ResponseError;
+    /**
+     * No such run, or not one you may read.
+     */
+    404: ResponseError;
+    /**
+     * The cursor's position is no longer available — restart from the `availableSinceMs` named in the message.
+     */
+    410: ResponseError;
+};
+type GetLiveRunSignalsError = GetLiveRunSignalsErrors[keyof GetLiveRunSignalsErrors];
+type GetLiveRunSignalsResponses = {
+    /**
+     * One page of signals
+     */
+    200: LiveSignalPage;
+};
+type GetLiveRunSignalsResponse = GetLiveRunSignalsResponses[keyof GetLiveRunSignalsResponses];
+type MintLiveConnectionTokenData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/live/token";
+};
+type MintLiveConnectionTokenResponses = {
+    /**
+     * Token minted
+     */
+    200: LiveConnectionToken;
+};
+type MintLiveConnectionTokenResponse = MintLiveConnectionTokenResponses[keyof MintLiveConnectionTokenResponses];
 type ClientOptions = {
     baseUrl: "https://api.qtsurfer.net/v1" | "https://api.qtsurfer.com/v1" | (string & {});
 };
@@ -2645,6 +3326,24 @@ type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean
  *
  */
 declare const authenticate: <ThrowOnError extends boolean = false>(options?: Options<AuthenticateData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AuthTokenResponse, unknown, ThrowOnError>;
+/**
+ * Get your account's identity and tier limits
+ * Your userId, current tier, and that tier's limits — no database call, safe to fetch on
+ * every page load. For live usage against these limits, see `_links.usage`
+ * (`GET /account/usage`).
+ *
+ */
+declare const getAccount: <ThrowOnError extends boolean = false>(options?: Options<GetAccountData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<Account, unknown, ThrowOnError>;
+/**
+ * Get your live storage usage
+ * How much of your account's shared storage pool (`GET /account`'s `maxTotalStorageBytes`)
+ * you're currently using. Datasets, strategy-execution signals, and registered strategies
+ * all count against the same total — they compete for the same underlying storage, so
+ * there's one number to watch, not one per resource type. Not guaranteed real-time — a
+ * just-completed upload or strategy execution may take a short moment to be reflected here.
+ *
+ */
+declare const getAccountUsage: <ThrowOnError extends boolean = false>(options?: Options<GetAccountUsageData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AccountUsage, unknown, ThrowOnError>;
 /**
  * List the available exchanges
  */
@@ -2730,22 +3429,35 @@ declare const listStrategies: <ThrowOnError extends boolean = false>(options?: O
  * Compile and register a strategy
  * Compiles raw strategy source and registers it, returning its `strategyId`.
  *
- * **This answers one question: is the source valid Java.** It compiles, registers, and hands
+ * The source is either **Java** — a class extending a strategy base class — or **QTScript**
+ * (beta), a compact strategy language whose braced bodies are plain Java. QTScript source
+ * begins with the `strategy` keyword — whitespace and comments (`//` or `* *`) before it
+ * are ignored — and that is how the two are told apart: there is no separate endpoint and
+ * no header to set. Once registered, a strategy is used the same way
+ * whichever language it was written in.
+ *
+ * **This answers one question: is the source valid.** It compiles, registers, and hands
  * back the id — nothing more. Whether the class can actually run is
  * `POST /strategy/{strategyId}/validate`, and everything known about a strategy, validation
  * included, is read from `GET /strategy/{strategyId}`. One place to ask, so there is no second
  * answer to keep in step.
  *
- * 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. Renaming a variable,
- * changing an identifier's case, reordering fields, or reordering statements inside a method
- * return a **different** one.
+ * 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.
+ * Renaming a variable, changing an identifier's case, reordering fields, or reordering
+ * statements inside a method return a **different** one.
+ *
+ * For **QTScript**, the id is derived from the text, because indentation is part of its
+ * grammar. Only differences that cannot change the strategy are ignored: a byte-order mark, the
+ * style of line endings, whitespace at the end of a line, and blank lines before the first and
+ * after the last line. Anything else — a comment, the indentation, a blank line in between —
+ * returns a **different** id.
  *
  * Two rules follow, and they are worth designing around:
  *
- * - re-submitting a strategy you have only reformatted is free, and gives you back the id you
- * already had, along with any validation already recorded against it;
+ * - re-submitting a Java strategy you have only reformatted is free, and gives you back the id
+ * you already had, along with any validation already recorded against it;
  * - the id says nothing about *behaviour*. Two sources that compute the same thing by
  * different means are two strategies, because deciding otherwise would mean deciding program
  * equivalence.
@@ -2825,6 +3537,10 @@ declare const getStrategyCode: <ThrowOnError extends boolean = false>(options: O
  * The same params always return the same `jobId` (idempotent). Repeated calls with identical
  * params do not enqueue duplicate work — they reuse the existing job.
  *
+ * Every source in `DataSourceType` can be prepared, but not every one can then be run: `funding`
+ * data can be prepared and is rejected by `execute` and `executeSweep`. A `kline` prepare takes
+ * the bar width from `cadence` — see `PrepareRequest`.
+ *
  * **`exchangeId: user` is reserved for your own uploaded data.** Instead of a managed
  * exchange, it prepares from a dataset you created via `POST /datasets` (see the **Dataset**
  * endpoints) — send `datasetId` in place of `instrument`. See `PrepareRequest` below for the
@@ -2848,6 +3564,10 @@ declare const getPrepareStatus: <ThrowOnError extends boolean = false>(options:
  * The backend expands and executes the matrix internally; clients poll the returned
  * `sweepId` for incremental results.
  *
+ * `type` must be `ticker` or `kline`; a `kline` sweep, walk-forward included, runs over bars of
+ * the cadence the request was prepared at. `funding` can be prepared but not swept yet: it is
+ * rejected with `400` before anything is queued.
+ *
  * Supplying `walkForward` runs the sweep in a different mode entirely. Instead of scoring
  * every parameter vector once over the whole range, the data is split into F sequential
  * folds; each fold optimizes the full grid on its own window and then scores only its winner
@@ -2954,6 +3674,11 @@ declare const getSweepRunEquityCurve: <ThrowOnError extends boolean = false>(opt
  * Returns immediately with a `jobId`; poll `GET /backtest/{exchangeId}/{type}/execute/{jobId}`
  * for the result.
  *
+ * `type` must be a source that can be executed: `ticker` or `kline`. A `kline` strategy is fed
+ * bars of the cadence its `prepareJobId` was prepared at — chosen by you when preparing, not by
+ * the strategy. `funding` can be prepared but not executed yet: it is rejected with `400`
+ * before anything is queued.
+ *
  * Optionally takes `params`: strategy properties for this one run, applied without
  * recompiling. This is how a sweep leaderboard winner gets re-run for its `equityCurve` —
  * a sweep row carries the ten ranking metrics but never a curve, whatever its size. Compile
@@ -3029,16 +3754,21 @@ declare const listDatasets: <ThrowOnError extends boolean = false>(options?: Opt
  * response. `instrument` must be a plain spot pair (`BASE/QUOTE`, exactly one `/`); derivative
  * forms (e.g. `BTC/USDT:USDT`) are rejected.
  *
- * **Upload format.** A CSV with a header row, or a parquet file with the same columns by
- * name. Required: `timestamp` (ISO-8601, or numeric epoch seconds/millis/micros — detected
- * from the first row, then enforced for every later row), `close`. Optional: `open`, `high`,
- * `low`, `volume`, `quoteVolume`, `bid`, `bidSize`, `ask`, `askSize`. Cadence and timestamp
- * unit are discovered from the data, not declared.
+ * **Upload format.** A CSV with a header row, a parquet file with the same columns by
+ * name, or a lastra file — our own native columnar format, the same one a dataset's
+ * `dataUrl` hands back by default, so a downloaded dataset can be handed to another user to
+ * upload with no conversion in between. For CSV/parquet, required: `timestamp` (ISO-8601, or
+ * numeric epoch seconds/millis/micros — detected from the first row, then enforced for every
+ * later row), `close`. Optional: `open`, `high`, `low`, `volume`, `quoteVolume`, `bid`,
+ * `bidSize`, `ask`, `askSize`. A lastra upload carries its own fixed column set instead and
+ * only needs a timestamp series and a close series present. Cadence and timestamp unit are
+ * discovered from the data, not declared, for all three.
  *
  * A CSV upload is converted to our native columnar format (`lastra`) for storage. A parquet
- * upload is stored as-is today. Either way, always check `dataFormat` on
+ * or lastra upload is stored as-is today. Either way, always check `dataFormat` on
  * `GET /datasets/{datasetId}` and `GET /datasets/{datasetId}/uploads/{uploadId}` for which
- * one `dataUrl` actually is, rather than assuming from how you uploaded it.
+ * one `dataUrl` actually is, rather than assuming from how you uploaded it (a converted CSV
+ * and an uploaded lastra file both report `dataFormat: "lastra"`).
  *
  * The bytes PUT to `upload.url` may be that file directly, gzipped (`.gz`), or zipped
  * (`.zip`, exactly one file inside — a dataset is one file regardless of how it travels).
@@ -3134,7 +3864,126 @@ declare const importDataset: <ThrowOnError extends boolean = false>(options: Opt
  *
  */
 declare const getDatasetImport: <ThrowOnError extends boolean = false>(options: Options<GetDatasetImportData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DatasetImportState, ResponseError, ThrowOnError>;
+/**
+ * Stop this strategy's live run
+ * 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.
+ *
+ */
+declare const stopLive: <ThrowOnError extends boolean = false>(options: Options<StopLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRun, ResponseError, ThrowOnError>;
+/**
+ * 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.
+ *
+ */
+declare const getLive: <ThrowOnError extends boolean = false>(options: Options<GetLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRun, 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**
+ * 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`.
+ *
+ * Only one run per strategy at a time — starting again while one is already running is `409`;
+ * stop the current one first.
+ *
+ * `sources` takes exactly one entry today (multi-source strategies are not supported yet).
+ * `type` is `ticker` or `kline`; anything else is rejected. Both connect to the lightest
+ * (fastest) cadence available for the exchange — today that is 1 tick/second on every
+ * supported exchange; choosing among several cadences is not offered yet.
+ *
+ * `params` is passed straight through to the strategy at start — the same free-form object
+ * `POST /strategy/{strategyId}/validate` and the backtest endpoints already accept. To change
+ * a parameter **while the run is live**, use `PUT /live/{runId}/params` instead; this endpoint
+ * only sets the values a run starts with.
+ *
+ * Consuming a run's own output — its signals, and updating its parameters over a live
+ * connection instead of polling — is a WebSocket protocol on top of these REST endpoints; see
+ * the "Live execution" guide linked from this tag's description for the full flow (minting a
+ * connection token, the channel and RPC method).
+ *
+ */
+declare const startLive: <ThrowOnError extends boolean = false>(options: Options<StartLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRun, 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.
+ *
+ * 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>;
+/**
+ * Change a run's visibility, name, or description
+ * Owner only, addressed by `runId` directly rather than through its strategy — this is a
+ * run's own canonical identity, independent of which strategy started it.
+ *
+ * Setting `visibility` from `public` back to `private` also evicts anyone currently connected
+ * to the run's live signal channel who is not its owner — best-effort; the change to this
+ * record is not rolled back if that eviction fails.
+ *
+ */
+declare const updateLive: <ThrowOnError extends boolean = false>(options: Options<UpdateLiveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveRunCompact, ResponseError, ThrowOnError>;
+/**
+ * Change a running strategy's parameters
+ * Updates one or more parameters of a run **while it stays live** — unlike `params` on
+ * `POST /strategy/{strategyId}/live`, which only sets the starting values. Owner only.
+ *
+ * Every key in `params` must be one your strategy declares (see `declaredProperties` on
+ * `POST /strategy`) as of the compilation this run is executing — recompiling the strategy
+ * later never changes what an already-running instance accepts; start a new run for that.
+ *
+ * The change does not take effect the instant this call returns: `effectiveAtMs` is the
+ * earliest moment it is guaranteed to apply, a few seconds out, so both the REST and
+ * WebSocket paths to this same update (see the "Live execution" guide) land on the exact same
+ * value at the exact same moment.
+ *
+ */
+declare const updateLiveParams: <ThrowOnError extends boolean = false>(options: Options<UpdateLiveParamsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveParamsUpdateResult, ResponseError, ThrowOnError>;
+/**
+ * Read a run's signals
+ * Returns one page of the signals a run has already produced, newest-last, optionally from a
+ * given time and narrowed to one or more instruments.
+ *
+ * This is the counterpart to the real-time WebSocket channel: that channel only carries what
+ * happens while you are connected, and only for a run that asked for `relay`. A run's signals
+ * are recorded either way, so this endpoint serves them whether or not `relay` was ever on,
+ * in both the `sandbox` and `live` stages — use it to catch up after a disconnect, to read a
+ * run you never relayed, or to page back over what has already happened.
+ *
+ * **The available window moves.** Signals are kept for a limited span, and the oldest are
+ * continuously discarded as new ones arrive, so how far back you can read is not a fixed
+ * number of hours: on a busy run it can be a good deal shorter. Every response carries
+ * `availableSinceMs`, the oldest moment that can still be answered for. Asking for a
+ * `sinceMs` older than that is not an error — you get everything from `availableSinceMs`
+ * onwards, and that field tells you it happened.
+ *
+ * **A cursor can expire, and on a busy run it expires quickly.** If the position a cursor
+ * points at has since been discarded, the next page answers `410` rather than silently
+ * 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.
+ *
+ */
+declare const getLiveRunSignals: <ThrowOnError extends boolean = false>(options: Options<GetLiveRunSignalsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveSignalPage, ResponseError, ThrowOnError>;
+/**
+ * Mint a WebSocket connection token
+ * Mints a short-lived token for the WebSocket connection used to receive a run's signals in
+ * real time and to call `live.params` (the WebSocket form of `PUT /live/{runId}/params`) —
+ * see the "Live execution" guide linked from this tag's description for the full protocol.
+ * Carries no request body.
+ *
+ */
+declare const mintLiveConnectionToken: <ThrowOnError extends boolean = false>(options?: Options<MintLiveConnectionTokenData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<LiveConnectionToken, unknown, ThrowOnError>;
 
 declare const client: _hey_api_client_fetch.Client;
 
-export { type AcceptedJob, 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 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 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 ListSegmentInstrumentsData, type ListSegmentInstrumentsError, type ListSegmentInstrumentsErrors, type ListSegmentInstrumentsResponse, type ListSegmentInstrumentsResponses, type ListStrategiesData, type ListStrategiesResponse, type ListStrategiesResponses, 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 ResponseError, type ResultMap, type ScalarStrategyParamValue, 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 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, getBacktestResult, getDataset, getDatasetImport, getDatasetUpload, getPrepareStatus, getStrategy, getStrategyCode, getSweepResult, getSweepRunEquityCurve, getSweepSensitivity, importDataset, listDatasets, listExchanges, listInstruments, listSegmentInstruments, listStrategies, openDatasetUpload, prepareBacktest, 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 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 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 LiveParamsUpdateResult, type LiveRun, type LiveRunCompact, type LiveSignal, type LiveSignalInstrument, type LiveSignalOrder, type LiveSignalPage, type LiveSource, type MintLiveConnectionTokenData, type MintLiveConnectionTokenResponse, type MintLiveConnectionTokenResponses, type Notice, type OpenDatasetUploadData, type OpenDatasetUploadError, type OpenDatasetUploadErrors, type OpenDatasetUploadResponse, type OpenDatasetUploadResponses, type Options, type PrepareBacktestData, type PrepareBacktestError, type PrepareBacktestErrors, type PrepareBacktestResponse, type PrepareBacktestResponses, type PrepareJobState, type PrepareRequest, type PublicLiveListLinks, type PublicLiveListResponse, type PublicLiveNextLink, type PublicLiveRun, type ResponseError, type ResultMap, type ScalarStrategyParamValue, type StartLiveData, type StartLiveError, type StartLiveErrors, type StartLiveRequest, type StartLiveResponse, type StartLiveResponses, type StopLiveData, type StopLiveError, type StopLiveErrors, type StopLiveResponse, type StopLiveResponses, type StrategyId, type StrategyLinks, type StrategyState, type StrategySummary, type SweepAxis, type SweepBaseConfig, type SweepHeatmap, type SweepHeatmapCell, type SweepMarginal, type SweepMarginalPoint, type SweepProgress, type SweepRunRow, type SweepSensitivity, type SweepSpecRequest, type UpdateLiveData, type UpdateLiveError, type UpdateLiveErrors, type UpdateLiveParamsData, type UpdateLiveParamsError, type UpdateLiveParamsErrors, type UpdateLiveParamsRequest, type UpdateLiveParamsResponse, type UpdateLiveParamsResponses, type UpdateLiveRequest, type UpdateLiveResponse, type UpdateLiveResponses, type ValidateStrategyData, type ValidateStrategyError, type ValidateStrategyErrors, type ValidateStrategyResponse, type ValidateStrategyResponses, type WalkForwardAccepted, type WalkForwardFold, type WalkForwardRequest, type WalkForwardResult, authenticate, cancelBacktest, cancelSweep, client, compileStrategy, createDataset, deleteDataset, deleteStrategy, downloadKlines, downloadTickers, executeBacktest, executeSweep, finalizeDatasetUpload, getAccount, getAccountUsage, getBacktestResult, getDataset, getDatasetImport, getDatasetUpload, getLive, getLiveRunSignals, getPrepareStatus, getStrategy, getStrategyCode, getSweepResult, getSweepRunEquityCurve, getSweepSensitivity, importDataset, listDatasets, listExchanges, listInstruments, listPublicLive, listSegmentInstruments, listStrategies, mintLiveConnectionToken, openDatasetUpload, prepareBacktest, startLive, stopLive, updateLive, updateLiveParams, validateStrategy };