@qtsurfer/api-client 0.14.0 → 0.15.0

package/dist/index.d.ts

@@ -14,6 +14,10 @@ type ResponseError = {
      */
     message: string;
 };
+/**
+ * A scalar strategy property value for one execution.
+ */
+type ScalarStrategyParamValue = number | string | boolean;
 /**
  * Exchange instrument identifier (e.g. a currency pair)
  */
@@ -212,14 +216,22 @@ type PrepareRequest = {
      */
     to: string;
     /**
-     * Output bar cadence for the prepared range. Defaults to the publisher's
-     * native cadence (`1s`); coarser cadences are produced on demand via
-     * resampling and stored alongside the native blob in cache. Coarser-than-
-     * source values must be exact multiples of the source cadence — invalid
-     * labels return `400`.
+     * Output bar cadence for the prepared range. Coarser cadences are produced on demand by
+     * resampling the source and stored alongside the native blob in cache. A target finer
+     * 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.
+     * * 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
+     * managed-exchange list (e.g. `15s`); an `rt` dataset can be resampled to any fixed
+     * cadence.
      *
      */
-    cadence?: "1s" | "5s" | "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "8h" | "12h" | "1d" | "1w" | "1q";
+    cadence?: string;
 };
 /**
  * Information about a single job
@@ -233,7 +245,8 @@ type JobState = {
      * Current status of the job. Treat `Completed | Aborted | Failed` as
      * terminal; `New | Started` mean keep polling. A single-instrument prepare
      * is always terminal (`Completed`) — decide from
-     * `PrepareJobState.coverageRatio`, not by polling.
+     * `PrepareJobState.coverageRatio` (or `dataFrom`/`dataTo` against an `rt` dataset,
+     * which has no ratio), not by polling.
      *
      */
     status: "New" | "Started" | "Completed" | "Aborted" | "Failed";
@@ -270,8 +283,10 @@ type JobState = {
  * dataset-backed prepare (`exchangeId: user`), coverage is reported on the dataset's own
  * cadence grid instead — hour-walking a daily dataset would report `1/24` and read as
  * broken — via `cadence`/`gaps`/`largestGapSteps`; `totalHours`/`hoursWithData`/
- * `hoursWithoutData` are absent in that case. `dataFrom`/`dataTo`/`coverageRatio` are present
- * either way, computed accordingly.
+ * `hoursWithoutData` are absent in that case. `dataFrom`/`dataTo` are present either way, and
+ * `coverageRatio` too, computed accordingly — except against a dataset whose `cadence` is `rt`:
+ * with no fixed step there is no expected row count to measure against, so `coverageRatio`
+ * is absent and `gaps`/`largestGapSteps` are `0`.
  *
  */
 type PrepareJobState = JobState & {
@@ -288,7 +303,8 @@ type PrepareJobState = JobState & {
      * `totalHours` is 0), the fraction of hours in the requested range that have served
      * data. Against a dataset (`exchangeId: user`): `rows / expectedStepsAtCadence`
      * over the dataset version's own range — echoing what ingest computed once, not
-     * recomputed against a narrower prepare request.
+     * recomputed against a narrower prepare request. Absent for an `rt` dataset (no
+     * fixed step, so no expected row count).
      *
      */
     coverageRatio?: number;
@@ -305,20 +321,21 @@ type PrepareJobState = JobState & {
      */
     hoursWithData?: number;
     /**
-     * The dataset version's own discovered cadence (e.g. `1m`, `1h`). Only present for a
-     * dataset-backed prepare (`exchangeId: user`).
+     * The dataset version's own discovered cadence — a fixed grid (e.g. `1m`, `1h`) or
+     * `rt` (see `DatasetVersion.cadence`). Only present for a dataset-backed prepare
+     * (`exchangeId: user`).
      *
      */
     cadence?: string;
     /**
      * Number of gaps in the dataset version at its own cadence, as discovered at ingest
-     * time. Only present for a dataset-backed prepare.
+     * time. `0` for `rt`. Only present for a dataset-backed prepare.
      *
      */
     gaps?: number;
     /**
-     * The largest gap in the dataset version, in units of its own cadence step. Only
-     * present for a dataset-backed prepare.
+     * The largest gap in the dataset version, in units of its own cadence step. `0` for
+     * `rt`. Only present for a dataset-backed prepare.
      *
      */
     largestGapSteps?: number;
@@ -527,7 +544,7 @@ type SweepRunRow = {
      */
     neighbourCount?: number;
     /**
-     * Probability that this run's Sharpe reflects real edge rather than the best draw from however many parameter vectors were tried. Above ~0.95 the result survives the multiple-testing correction; near 0.5 or below it is indistinguishable from the best of a pile of coin flips. Absent on aborted runs, and on sweeps with too few trials to establish any dispersion to deflate against.
+     * Probability that this run's Sharpe reflects real edge rather than the best draw from however many parameter vectors were tried. Above ~0.95 the result survives the multiple-testing correction; near 0.5 or below it is indistinguishable from the best of a pile of coin flips. Absent on aborted runs, on sweeps with too few trials to establish any dispersion to deflate against, on runs with fewer than 3 period returns, and on a degenerate (near-constant) return series — all cases where the underlying statistic isn't meaningfully computable, rather than genuinely zero. A present value is the computed probability, however small.
      */
     deflatedSharpe?: number;
     params: {
@@ -560,7 +577,10 @@ type SweepRunRow = {
     aborted: boolean;
     runtimeMs: number;
     /**
-     * Present only when this trial's curve was selected (`equityCurve.mode` was `topN`/`topPct` on the request, and this row ranked among the winners) — absent, not null, otherwise; a run that was never spilled and one that was spilled but not selected look identical here. Always a pointer today (`url` present, no inline points): a sweep's curves live in a spill store, not the response, until fetched separately. `GET` the `url` to fetch the curve itself; its own `meta` there is the real, possibly size-guarded outcome, while this outer `meta` is a raw, untransformed preview from selection time and can differ.
+     * Present whenever this trial actually has a curve — which is any completed run of a sweep that requested curves at all (`equityCurve.mode` `topN`/`topPct`), not only the ranked winners. Absent, not null, when there is genuinely nothing: the run aborted, it made no trades, or the sweep never retained curves (`mode` `auto`/`none`).
+     * Selection decides how the curve travels, not whether it exists. A row may carry `url` alone, or `url` together with the points inline.
+     * **Read `points`/`equities` to tell whether the curve is inline — never the presence of this object, and never the absence of `url`.** Both mislead, and in opposite directions: this object is present on rows that carry only a pointer, and `url` stays present alongside an inline curve so a caller can still re-request a different transform. An inline curve is emitted on the materialisation view (`?order=natural`), where each row is read once; the ranked view keeps the pointer, being polled.
+     * When only a pointer is present, `GET` the `url` for the curve. Its own `meta` there is the real, possibly size-guarded outcome. This outer `meta` may be a declaration rather than a measurement — for a row whose curve was not promoted, the point count is derived from the trade count (one equity point per closed trade) instead of being read from the store, to keep a polled response from doing per-row work.
      */
     equityCurve?: EquityCurveResult;
 };
@@ -660,7 +680,8 @@ type ExecuteSweepResult = {
      * The same `JobState` shape a single-execute `BacktestJobResult` carries — not a sweep-specific lookalike, the actual type, so field names and timestamp formatting match exactly.
      * `state.status` uses `JobState`'s own vocabulary (`New`/`Started`/`Completed`/ `Aborted`/`Failed`), mapped from the sweep's `status` field above rather than copying it: `PARTIAL` and `CANCELLED` both map to `Aborted`, because a sweep's `PARTIAL` is already terminal (some shards finished, some failed, nothing more is coming) unlike a single job's non-terminal `Partial`, which has no equivalent here at all.
      * `state.completed` is real ticks processed on a plain sweep. On a `walkForward` sweep it is currently always `0` — the walk-forward fold runner was not wired to count ticks when this shipped, unlike the plain shard path.
-     * `state.size` is always `0` on every path (single execute, plain sweep, walk-forward alike) — nothing populates it anywhere yet. That is a known gap across the whole API, not a sweep-specific omission.
+     * `state.size` is an upfront estimate — range x the prepare's target cadence, set before any data is even loaded, not a query against loaded data — on a single execute and a plain sweep alike. A plain sweep's value is the sum of every shard's own `size` (each shard's per-run estimate x its own vector slice), the same additive shape `state.completed` already used above. `0` means the prepare context behind the job predates this field (a job whose prepare ran before the estimate existed) — never a guessed cadence standing in for a real one.
+     * On a `walkForward` sweep, `state.size` is still always `0`: fold runs were out of scope for the estimate the same way they are for `state.completed` above — a fold's `size` is simply never set, so the sum stays honest at `0` rather than needing a special case.
      */
     state: JobState;
 };
@@ -830,7 +851,7 @@ type ResultMap = {
      * The strategy properties this run was given, echoed back as sent. Absent when the request carried none, so its presence is what distinguishes a parameterised run from one at the declared defaults — a stored result cannot otherwise say which vector produced it, and this endpoint is meant to be called repeatedly over one prepare.
      */
     params?: {
-        [key: string]: number | string | boolean;
+        [key: string]: ScalarStrategyParamValue;
     };
     /**
      * Number of signals emitted during strategy execution
@@ -1111,9 +1132,12 @@ type Dataset = {
      */
     name: string;
     /**
-     * Always `ticker` in v1.
+     * `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.
+     *
      */
-    type: "ticker";
+    type: "ticker" | "klines";
     instrument: Instrument;
     /**
      * When the dataset was created.
@@ -1142,8 +1166,8 @@ type Dataset = {
      */
     to?: string;
     /**
-     * `currentVersionId`'s own discovered bar cadence (e.g. `1s`, `1m`, `1h`). Absent until a
-     * version exists.
+     * `currentVersionId`'s own discovered cadence — a fixed grid (e.g. `1s`, `1m`, `1h`) or
+     * `rt` (see `DatasetVersion.cadence`). Absent until a version exists.
      *
      */
     cadence?: string;
@@ -1152,6 +1176,23 @@ type Dataset = {
  * A `Dataset` plus a self link. Returned by `GET /datasets/{datasetId}`.
  */
 type DatasetWithLinks = Dataset & {
+    /**
+     * Presigned GET URL to the current version's stored file — see `dataFormat` for
+     * which format it's actually in. Present only once the current version's status is
+     * `ready`. Long-lived (day-scale, not permanent): a DuckDB-WASM/`lastra-ts`-style
+     * reader issues HTTP range requests against it lazily over an extended viewing
+     * session, not in one shot like a browser upload.
+     *
+     */
+    dataUrl?: string;
+    /**
+     * 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.
+     *
+     */
+    dataFormat?: "lastra" | "parquet";
     _links?: {
         self?: {
             href?: string;
@@ -1163,8 +1204,9 @@ type DatasetWithLinks = Dataset & {
  */
 type DatasetUploadTarget = {
     /**
-     * Presigned URL. `PUT` the raw CSV file here directly — no `Authorization` header,
-     * no other API credentials.
+     * Presigned URL. `PUT` the file here directly — the CSV or parquet itself, or a `.gz`/`.zip` of it
+     * (see `createDataset`'s own description) — no `Authorization` header, no other API
+     * credentials.
      *
      */
     url: string;
@@ -1222,7 +1264,7 @@ type DatasetVersion = {
      */
     id?: string;
     /**
-     * Size of the uploaded file.
+     * Size of the stored file `dataUrl` points at — a converted `lastra` for a CSV/gzip/zip upload, or the parquet file itself, unconverted, for a parquet upload. Not the size of the bytes originally PUT to storage; see `dataFormat`.
      */
     bytes?: number;
     /**
@@ -1230,7 +1272,13 @@ type DatasetVersion = {
      */
     rows?: number;
     /**
-     * The discovered bar cadence (e.g. `1s`, `1m`, `1h`).
+     * 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.
+     *
      */
     cadence?: string;
     /**
@@ -1240,16 +1288,32 @@ type DatasetVersion = {
      */
     timestampUnit?: "iso" | "s" | "ms" | "us";
     /**
-     * Number of gaps at the discovered cadence.
+     * Number of gaps at the discovered cadence. Always `0` for `rt`.
      */
     gaps?: number;
     /**
-     * The largest gap, in units of the discovered cadence step.
+     * The largest gap, in units of the discovered cadence step. Always `0` for `rt`.
      */
     largestGapSteps?: number;
+    /**
+     * Presigned GET URL to the stored file — see `dataFormat` for which format it's in.
+     * Present once the version is `ready`. Long-lived (day-scale, not permanent): a
+     * DuckDB-WASM/`lastra-ts`-style reader issues HTTP range requests against it lazily over
+     * an extended viewing session, not in one shot like a browser upload.
+     *
+     */
+    dataUrl?: string;
+    /**
+     * 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.
+     *
+     */
+    dataFormat?: "lastra" | "parquet";
 };
 /**
- * Progress of one upload, from staged through ingest. Postgres-backed once a version exists,
+ * Progress of one upload, from staged through ingest. Durably recorded once a version exists,
  * so `ready`/`failed` are permanent answers; `uploading`/`ingesting` reflect in-flight state
  * that can itself age out — see the `404` case on `GET .../uploads/{uploadId}`.
  *
@@ -1261,7 +1325,8 @@ type DatasetUploadState = {
      * called yet.
      * * `ingesting` — `finalize` was called; the worker is parsing and validating the file.
      * * `ready` — ingested successfully. `version` carries the result.
-     * * `failed` — ingest rejected the file (e.g. bad CSV contract, mixed timestamp units).
+     * * `failed` — ingest rejected the file (e.g. bad CSV contract, mixed timestamp units, a
+     * `.zip` with no file inside or more than one).
      *
      */
     status: "uploading" | "ingesting" | "ready" | "failed";
@@ -1269,6 +1334,150 @@ type DatasetUploadState = {
      * The ingest job id, while `status` is `ingesting`.
      */
     jobId?: string;
+    /**
+     * A human-readable reason, present when `status` is `failed` (e.g. bad CSV contract,
+     * mixed timestamp units, a `.zip` with no file inside or more than one). Durably
+     * recorded alongside the failure itself, so it stays available however long after the
+     * fact you poll — not tied to how recently the failure happened.
+     *
+     */
+    error?: string;
+    /**
+     * Present when `status` is `ready` or `failed`.
+     */
+    version?: DatasetVersion;
+};
+/**
+ * `POST /datasets/imports`'s request body. A common block plus one type-specific block,
+ * selected by `type` — `dex` is the only value today.
+ *
+ */
+type DatasetImportRequest = {
+    /**
+     * A name unique among your datasets. `409` if already taken.
+     */
+    name: string;
+    instrument: Instrument;
+    /**
+     * Start of the range to fetch, inclusive. Must be before `to`.
+     */
+    from: string;
+    /**
+     * End of the range to fetch, exclusive. The total span is capped by your tier — a
+     * request wider than that ceiling is `400`, regardless of source type.
+     *
+     */
+    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`).
+     *
+     */
+    cadence?: "1s" | "1m" | "5m";
+    /**
+     * The source to fetch from. `dex` is the only value today.
+     */
+    type: "dex";
+    dex?: DatasetImportDexRequest;
+};
+/**
+ * The `dex` source's own fields — required when `type` is `dex`. `id`/`version` are required
+ * for a plain (native-cadence) import; both are ignored if the top-level `cadence` requested
+ * pre-aggregated candles instead, since that path needs neither a protocol nor a version
+ * distinction.
+ *
+ */
+type DatasetImportDexRequest = {
+    /**
+     * Which chain the pool/pair lives on.
+     */
+    network: "ethereum" | "robinhood";
+    /**
+     * Which on-chain DEX protocol `contract` implements. Required unless the top-level
+     * `cadence` requested pre-aggregated candles, in which case it's ignored.
+     *
+     */
+    id?: "uniswap";
+    /**
+     * Uniswap version the pool/pair contract implements. Required unless the top-level
+     * `cadence` requested pre-aggregated candles, in which case it's ignored.
+     *
+     */
+    version?: "v2" | "v3";
+    /**
+     * The pool (v3) or pair (v2) contract address.
+     */
+    contract: string;
+    /**
+     * The factory that deployed `contract`. Optional — when omitted, it is discovered
+     * on-chain from `contract` itself at fetch time. Supply it explicitly only if you
+     * already know it, or the pool/pair belongs to a factory other than the canonical one
+     * for `network`/`version`. Either way, the pool/pair is validated against whichever
+     * factory is used before anything is fetched — a wrong or unrelated factory fails the
+     * import rather than silently fetching from the wrong pool. Ignored if the top-level
+     * `cadence` requested pre-aggregated candles.
+     *
+     */
+    factory?: string;
+};
+/**
+ * The response to `POST /datasets/imports` — the dataset now exists, and its fetch has started.
+ */
+type DatasetImportCreated = {
+    /**
+     * Opaque id of the newly created dataset — same id space as `POST /datasets`.
+     */
+    datasetId: string;
+    /**
+     * Identifies this import. Pass to `GET /datasets/{datasetId}/imports/{importId}` to poll
+     * it — there is no separate "finalize" step the way an upload has.
+     *
+     */
+    importId: string;
+    /**
+     * The fetch/ingest job id.
+     */
+    jobId: string;
+    /**
+     * Always `fetching` in this response — the fetch has only just started.
+     */
+    status: "fetching";
+};
+/**
+ * Progress of one import, from fetching through ingest. `fetching` is the one status only an
+ * import ever reports — an upload's file already exists by the time you can poll it; an
+ * import's doesn't, until this source finishes fetching it.
+ *
+ */
+type DatasetImportState = {
+    importId: string;
+    /**
+     * * `fetching` — reading from the source; nothing staged yet.
+     * * `ingesting` — fetch complete, staged, and re-entered the same ingest chain an
+     * upload uses; the worker is parsing and validating it.
+     * * `ready` — ingested successfully. `version` carries the result.
+     * * `failed` — the fetch or the ingest that followed it was rejected. `error` names why.
+     *
+     */
+    status: "fetching" | "ingesting" | "ready" | "failed";
+    /**
+     * The fetch/ingest job id, while `status` is `fetching` or `ingesting`.
+     */
+    jobId?: string;
+    /**
+     * 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
+     * `DatasetUploadState.error`'s own ingest-side reasons once fetching hands off to it.
+     * Durably recorded, same as on the upload path.
+     *
+     */
+    error?: string;
     /**
      * Present when `status` is `ready` or `failed`.
      */
@@ -1715,8 +1924,8 @@ 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
      * the dataset's current upload has not finished ingesting, or `cadence` asks for a finer
-     * granularity than the dataset's own discovered cadence, or the requested range exceeds
-     * your tier's range limit.
+     * 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.
      *
      */
     400: ResponseError;
@@ -1980,6 +2189,16 @@ type ExecuteBacktestData = {
          */
         storeSignals?: boolean;
         equityCurve?: EquityCurveOptions;
+        /**
+         * Capital/fee/position-size overrides for this one run — the same shape
+         * `executeSweep`'s `baseConfig` accepts. Omit to run at the platform defaults
+         * (`initialFunding: 100`, `feeRate: 0.001`). `buyFeeRate`/`sellFeeRate`/`feeLeg`
+         * are accepted for shape compatibility with a sweep's `baseConfig`, but this
+         * endpoint has one fee-rate slot: a value that implies asymmetric buy/sell fees,
+         * or a non-default `feeLeg`, is rejected with `400`.
+         *
+         */
+        baseConfig?: SweepBaseConfig;
         /**
          * Strategy properties to apply to this run. Omit to run the strategy's declared
          * defaults, which is exactly what a request without this field has always done.
@@ -2000,7 +2219,7 @@ type ExecuteBacktestData = {
          *
          */
         params?: {
-            [key: string]: number | string | boolean;
+            [key: string]: ScalarStrategyParamValue;
         };
     };
     path: {
@@ -2327,6 +2546,75 @@ type GetDatasetUploadResponses = {
     200: DatasetUploadState;
 };
 type GetDatasetUploadResponse = GetDatasetUploadResponses[keyof GetDatasetUploadResponses];
+type ImportDatasetData = {
+    /**
+     * What to fetch, and where from
+     */
+    body: DatasetImportRequest;
+    path?: never;
+    query?: never;
+    url: "/datasets/imports";
+};
+type ImportDatasetErrors = {
+    /**
+     * Invalid request; `instrument` isn't a plain spot pair; `from >= to`; `cadence` present
+     * but not one of its supported values; the requested range exceeds your tier's import
+     * range ceiling; the requested range's rough size estimate exceeds your tier's row limit;
+     * `dex.network`/`dex.id` not one of their supported values; `dex.contract`/`dex.factory`
+     * fail basic shape validation; or, when `cadence` is omitted, `dex.id`/`dex.version`
+     * missing. Whether the pool/pair actually exists and resolves — and, for a candle
+     * `cadence`, whether that combination is actually servable on the requested `network` —
+     * is checked later, asynchronously — see the `failed` status on the poll endpoint below.
+     *
+     */
+    400: ResponseError;
+    /**
+     * You already have a dataset with this `name`
+     */
+    409: ResponseError;
+    /**
+     * Your tier's dataset count limit is reached. Delete one, or upgrade.
+     */
+    429: ResponseError;
+};
+type ImportDatasetError = ImportDatasetErrors[keyof ImportDatasetErrors];
+type ImportDatasetResponses = {
+    /**
+     * Dataset created, fetch started
+     */
+    202: DatasetImportCreated;
+};
+type ImportDatasetResponse = ImportDatasetResponses[keyof ImportDatasetResponses];
+type GetDatasetImportData = {
+    body?: never;
+    path: {
+        /**
+         * The id returned by `POST /datasets/imports`
+         */
+        datasetId: string;
+        /**
+         * The `importId` returned by `POST /datasets/imports`
+         */
+        importId: string;
+    };
+    query?: never;
+    url: "/datasets/{datasetId}/imports/{importId}";
+};
+type GetDatasetImportErrors = {
+    /**
+     * No such dataset for this user, or genuinely nothing is known about this `importId`.
+     *
+     */
+    404: ResponseError;
+};
+type GetDatasetImportError = GetDatasetImportErrors[keyof GetDatasetImportErrors];
+type GetDatasetImportResponses = {
+    /**
+     * Current fetch/ingest state
+     */
+    200: DatasetImportState;
+};
+type GetDatasetImportResponse = GetDatasetImportResponses[keyof GetDatasetImportResponses];
 type ClientOptions = {
     baseUrl: "https://api.qtsurfer.net/v1" | "https://api.qtsurfer.com/v1" | (string & {});
 };
@@ -2673,15 +2961,22 @@ declare const getSweepRunEquityCurve: <ThrowOnError extends boolean = false>(opt
  * backtest result with the curve included.
  *
  * The same request (same `prepareJobId`, `strategyId`, `storeSignals`, `equityCurve`,
- * `params`) always returns the same `jobId` (idempotent) — a request that omits `equityCurve`
- * or `params` dedupes exactly as it did before those fields existed. Two different `params`
- * vectors over one prepare are two different jobs, and `9` and `9.0` are the same one.
+ * `baseConfig`, `params`) always returns the same `jobId` (idempotent) — a request that omits
+ * `equityCurve`, `baseConfig` or `params` dedupes exactly as it did before those fields
+ * existed. Two different `params` vectors over one prepare are two different jobs, and `9`
+ * and `9.0` are the same one.
  *
  * The re-run is an independent execution rather than a replay of the sweep trial — the two
  * paths do not share a simulator — but they are pinned to agree: one vector run both ways
  * matches on every leaderboard metric, asserted as a regression test. Treat a difference as a
  * bug worth reporting, not as expected behaviour.
  *
+ * Optionally takes `baseConfig`, the same `SweepBaseConfig` shape `executeSweep` accepts —
+ * `initialFunding`, `feeRate`, `percentAmountToLock`, etc. — so the same object can be reused
+ * against either endpoint. This endpoint has one effective fee rate rather than a sweep's
+ * independent buy/sell legs: a `baseConfig` that resolves to different buy/sell rates, or sets
+ * a non-default `feeLeg`, is rejected with `400` rather than silently collapsed to one side.
+ *
  * Works unchanged for a dataset-backed prepare (`exchangeId: user`) — the request body is
  * identical either way, since the instrument and range are recovered from `prepareJobId`.
  *
@@ -2734,11 +3029,22 @@ 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. Required columns: `timestamp` (ISO-8601, or
- * numeric epoch seconds/millis/micros — detected from the first row, then enforced for every
- * later row), `close`. Optional columns: `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, 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.
+ *
+ * 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
+ * `GET /datasets/{datasetId}` and `GET /datasets/{datasetId}/uploads/{uploadId}` for which
+ * one `dataUrl` actually is, rather than assuming from how you uploaded it.
+ *
+ * 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).
+ * Format is detected from the decompressed content itself: there is no filename or
+ * `Content-Type` anywhere in this flow for a client to declare it with, so nothing needs to
+ * be sent besides the bytes.
  *
  */
 declare const createDataset: <ThrowOnError extends boolean = false>(options: Options<CreateDatasetData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DatasetCreated, ResponseError, ThrowOnError>;
@@ -2794,7 +3100,41 @@ declare const finalizeDatasetUpload: <ThrowOnError extends boolean = false>(opti
  *
  */
 declare const getDatasetUpload: <ThrowOnError extends boolean = false>(options: Options<GetDatasetUploadData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DatasetUploadState, ResponseError, ThrowOnError>;
+/**
+ * Create a dataset by importing history instead of uploading it
+ * A second way to get data into a dataset, alongside `POST /datasets`: instead of `PUT`ting a
+ * file yourself, ask the API to go fetch history on your behalf. Creates the dataset and
+ * starts the fetch in the same call — there is no separate upload step, and the result lands
+ * 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.
+ *
+ * A `dex` import has two data shapes, chosen by the top-level `cadence`:
+ *
+ * * Omitted/blank (default) — on-chain swap history, replayed directly from the pool/pair's
+ * own chain. Cadence is native, not resampled: each swap keeps the timestamp it happened
+ * at rather than being bucketed into candles, so the resulting version's `cadence` is `rt`
+ * unless the swaps happen to sit on a fixed grid (see `DatasetVersion.cadence`).
+ * * One of `1s` / `1m` / `5m` — pre-aggregated candles at that width instead of raw trades.
+ * The resulting dataset's `type` is `klines`, not `ticker`. Not every network supports every
+ * cadence yet — an unsupported combination fails asynchronously, same as an unresolvable
+ * pool (see the `failed` status on the poll endpoint below).
+ *
+ */
+declare const importDataset: <ThrowOnError extends boolean = false>(options: Options<ImportDatasetData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DatasetImportCreated, ResponseError, ThrowOnError>;
+/**
+ * Get the state of an import/ingest
+ * Poll after `POST /datasets/imports` until `status` is `ready` or `failed`. An import spends
+ * real time fetching from its source before anything is even staged — `fetching` is the one
+ * status only an import ever reports; `ingesting`/`ready`/`failed` mean exactly what they do
+ * on `GET /datasets/{datasetId}/uploads/{uploadId}`, since an import re-enters that same
+ * ingest chain once it has fetched and staged its data.
+ *
+ */
+declare const getDatasetImport: <ThrowOnError extends boolean = false>(options: Options<GetDatasetImportData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DatasetImportState, ResponseError, 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 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 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 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 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, getDatasetUpload, getPrepareStatus, getStrategy, getStrategyCode, getSweepResult, getSweepRunEquityCurve, getSweepSensitivity, listDatasets, listExchanges, listInstruments, listSegmentInstruments, listStrategies, openDatasetUpload, prepareBacktest, validateStrategy };
+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 };