@qtsurfer/api-client 0.10.0 → 0.12.0

package/dist/index.d.ts

@@ -169,8 +169,32 @@ type Exchange = {
  * Managed exchange data sources available for backtesting.
  */
 type DataSourceType = "ticker";
+/**
+ * Two shapes, chosen by the `exchangeId` path segment. Against a managed exchange,
+ * `instrument` is required and `datasetId`/`datasetVersionId` are ignored. Against the
+ * reserved `exchangeId: user`, send `datasetId` instead of `instrument` — `instrument` is
+ * ignored there, since it comes from the dataset itself.
+ *
+ */
 type PrepareRequest = {
-    instrument: Instrument;
+    /**
+     * Required unless `exchangeId` is the reserved value `user`, in which case send
+     * `datasetId` instead.
+     *
+     */
+    instrument?: Instrument;
+    /**
+     * Only for `exchangeId: user`: the id of a dataset created via `POST /datasets`, in place
+     * of `instrument`. Ignored against a managed exchange.
+     *
+     */
+    datasetId?: string;
+    /**
+     * Only for `exchangeId: user`, and optional even then: pins a specific past version of
+     * the dataset instead of its current one. Defaults to the dataset's current version.
+     *
+     */
+    datasetVersionId?: string;
     /**
      * Start date for the preparation process. Supports the following formats:
      * - ISO-8601 (e.g. 2024-12-14T23:59:59Z)
@@ -195,7 +219,7 @@ type PrepareRequest = {
      * labels return `400`.
      *
      */
-    cadence?: "1s" | "5s" | "1m" | "5m" | "15m" | "1h" | "4h" | "1d";
+    cadence?: "1s" | "5s" | "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "8h" | "12h" | "1d" | "1w" | "1q";
 };
 /**
  * Information about a single job
@@ -235,12 +259,19 @@ type JobState = {
     endTime?: string | null;
 };
 /**
- * State of a single-instrument prepare job — the `JobState` shape plus a per-hour
- * data-coverage summary. A single-instrument prepare is always terminal
- * (`status: Completed`): the client decides what to do from `coverageRatio` (e.g.
- * execute if it is at or above a chosen threshold) rather than polling for missing
- * hours that may never arrive — a missing hour for one instrument usually means low
- * activity, not missing data.
+ * State of a single-instrument prepare job — the `JobState` shape plus a coverage summary.
+ * A single-instrument prepare is always terminal (`status: Completed`): the client decides
+ * what to do from `coverageRatio` (e.g. execute if it is at or above a chosen threshold)
+ * rather than polling for missing hours that may never arrive — a missing hour for one
+ * instrument usually means low activity, not missing data.
+ *
+ * **Two coverage shapes, by exchange vs. dataset.** Against a managed exchange, coverage is
+ * walked hour by hour: `totalHours`/`hoursWithData`/`hoursWithoutData`. Against a
+ * 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.
  *
  */
 type PrepareJobState = JobState & {
@@ -253,21 +284,48 @@ type PrepareJobState = JobState & {
      */
     dataTo?: string | null;
     /**
-     * `hoursWithData / totalHours` in `[0,1]` (`1.0` when `totalHours` is 0) — the
-     * fraction of hours in the requested range that have served data.
+     * Against a managed exchange: `hoursWithData / totalHours` in `[0,1]` (`1.0` when
+     * `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.
      *
      */
     coverageRatio?: number;
     /**
-     * Number of whole hours in the requested prepare range.
+     * Number of whole hours in the requested prepare range. Managed exchanges only —
+     * absent for a dataset-backed prepare.
+     *
      */
     totalHours?: number;
     /**
-     * Number of hours in the range that have data.
+     * Number of hours in the range that have data. Managed exchanges only — absent for
+     * a dataset-backed prepare.
+     *
      */
     hoursWithData?: number;
     /**
-     * One entry per hour in the range that has no data, with a rationale.
+     * The dataset version's own discovered cadence (e.g. `1m`, `1h`). 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.
+     *
+     */
+    gaps?: number;
+    /**
+     * The largest gap in the dataset version, in units of its own cadence step. Only
+     * present for a dataset-backed prepare.
+     *
+     */
+    largestGapSteps?: number;
+    /**
+     * One entry per hour in the range that has no data, with a rationale. Managed
+     * exchanges only — absent for a dataset-backed prepare.
+     *
      */
     hoursWithoutData?: Array<{
         /**
@@ -342,6 +400,41 @@ type ExecuteSweepRequest = {
      */
     minTradeFloor?: number;
     walkForward?: WalkForwardRequest;
+    equityCurve?: EquityCurveRequest;
+};
+/**
+ * Requested equity-curve transform, applied server-side in a fixed pipeline order: `resample` (point count) then `differential` (encoding) then `outMode` (JSON shape) — each stage assumes the previous one already ran. A server-side size guard can still force a smaller/deflated shape above its thresholds regardless of what is requested here — see `EquityCurveMeta` for what actually happened.
+ */
+type EquityCurveOptions = {
+    /**
+     * Downsample to at most this many points (extrema-preserving — the global max/min and the exact first/last point are always kept). Omit for no downsampling.
+     */
+    resample?: number;
+    /**
+     * Delta-encode both fields from the second (post-resample) point onward.
+     */
+    differential?: boolean;
+    /**
+     * Requested JSON shape.
+     */
+    outMode?: EquityCurveOutMode;
+};
+/**
+ * Selection (`mode`/`n`/`maxPct`) plus the transform preference (`resample`/`differential`/`outMode`) applied by `GET .../equityCurve` whenever ITS OWN query params are absent, for a curve this sweep retained. The transform half never affects retention or `sweepId` — a caller can always override it per-request at read time regardless of what was submitted here.
+ */
+type EquityCurveRequest = EquityCurveOptions & {
+    /**
+     * Which trials keep their per-point equity curve. `auto` retains curves only while the accumulated size stays within server limits; `topN`/`topPct` retain curves for the best-ranked trials explicitly; `none` retains no curves.
+     */
+    mode?: "auto" | "topN" | "topPct" | "none";
+    /**
+     * Trial count to retain when mode is topN.
+     */
+    n?: number;
+    /**
+     * Top percentage of trials to retain when mode is topPct.
+     */
+    maxPct?: number;
 };
 /**
  * Opt in to walk-forward validation. Present, the sweep runs as F sequential folds and the result gains a `walkForward` section; absent, nothing about the sweep changes. Two requests that differ only in this block are two different sweeps and do not deduplicate against each other.
@@ -454,6 +547,10 @@ type SweepRunRow = {
     belowTradeFloor: boolean;
     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.
+     */
+    equityCurve?: EquityCurveResult;
 };
 /**
  * Sensitivity aggregates over a sweep's stored rows. Marginals are always complete; heatmaps may be capped, in which case `heatmapsTruncated` is true.
@@ -513,6 +610,9 @@ type SweepHeatmapCell = {
 };
 type ExecuteSweepResult = {
     sweepId: string;
+    /**
+     * The sweep's own status vocabulary — not the same set `state.status` below uses. See `state` for why.
+     */
     status: "RUNNING" | "COMPLETED" | "PARTIAL" | "CANCELLED";
     objective: "sharpe" | "sortino" | "pnl" | "maxdd";
     order: "ranked" | "natural";
@@ -544,6 +644,13 @@ type ExecuteSweepResult = {
     truncated: boolean;
     leaderboard: Array<SweepRunRow>;
     walkForward?: WalkForwardResult;
+    /**
+     * 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: JobState;
 };
 /**
  * Present only on a sweep submitted with `walkForward`, and present from acceptance onward — its presence, not its contents, is what identifies a walk-forward sweep. `completedFolds` is 0 while the first fold is still running.
@@ -704,9 +811,9 @@ type ResultMap = {
      */
     maxDrawdownPercent?: number;
     /**
-     * Equity curve over the backtest. Element 0 is an anchor at the backtest `from` with `initialCapital`; the remaining points are one sample per emitted yield, in order. Use it to plot the strategy's running equity without re-deriving it from the yield history.
+     * Equity curve over the backtest. `points[0]` (or `timestamps[0]`/`equities[0]` in `SHORT` mode) is an anchor at the backtest `from` with `initialCapital`; the remaining points are one sample per emitted yield, in order. Use it to plot the strategy's running equity without re-deriving it from the yield history. Always inline for a plain backtest today — never a pointer (`url`); that shape exists only for a sweep row's top-N winners.
      */
-    equityCurve?: Array<EquityPoint>;
+    equityCurve?: EquityCurveResult;
     /**
      * Number of signals emitted during strategy execution
      */
@@ -745,6 +852,57 @@ type EquityPoint = {
      */
     equity: number;
 };
+/**
+ * JSON shape for an equity curve's points. `ARRAY` is `[{timestamp, equity}, ...]`; `SHORT` is `{timestamps: [...], equities: [...]}` (parallel arrays, no repeated key text). The one schema shared by every place `outMode` appears, request or response, so the two cannot drift to different value sets.
+ */
+type EquityCurveOutMode = "ARRAY" | "SHORT";
+/**
+ * What the transform pipeline actually did, computed from the observed outcome — never a copy of what was requested. Lets a caller detect a forced or no-op transform (e.g. a `resample` ceiling already above the curve's size is a legal no-op, reported honestly as `resampled: false`).
+ */
+type EquityCurveMeta = {
+    /**
+     * Size of the curve the transform pipeline received.
+     */
+    inputPointCount: number;
+    /**
+     * Size after the full pipeline (resample, then differential, then outMode).
+     */
+    outputPointCount: number;
+    /**
+     * True only if the resample stage actually changed the point count.
+     */
+    resampled: boolean;
+    /**
+     * True only if delta-encoding actually ran. Requesting it on a curve of 0 or 1 points has nothing to encode, so it does not run even if asked.
+     */
+    differential: boolean;
+    /**
+     * The actual JSON shape served. Present even when the points themselves are not (a pointer curve, `EquityCurveResult.url`) — a caller resolving that URL separately still needs to know how to parse what it gets back before fetching it. May override an explicit request above a server-side size threshold; this field, not the request, is the source of truth for what shape actually came back.
+     */
+    outMode: EquityCurveOutMode;
+};
+/**
+ * An equity curve, shaped per `meta.outMode`: `points` when `ARRAY`, `timestamps` + `equities` (parallel arrays) when `SHORT`. Used identically wherever a curve is returned — a plain backtest's inline `equityCurve` and a sweep row's `equityCurve` are the same type. `url` is present *instead of* any points when the curve is served by pointer rather than inline (a sweep row's top-N winners only): `GET` it separately to fetch this exact same shape with the points populated.
+ */
+type EquityCurveResult = {
+    meta: EquityCurveMeta;
+    /**
+     * Present when `meta.outMode` is `ARRAY` and the curve is inline (not a pointer).
+     */
+    points?: Array<EquityPoint>;
+    /**
+     * Present when `meta.outMode` is `SHORT` and the curve is inline (not a pointer).
+     */
+    timestamps?: Array<number>;
+    /**
+     * Present when `meta.outMode` is `SHORT` and the curve is inline (not a pointer), parallel to `timestamps` (same index, same point).
+     */
+    equities?: Array<number>;
+    /**
+     * Present only for a sweep row's pointer curve. `GET` this to fetch the curve itself, in this exact `{points|timestamps+equities, meta}` shape — `meta` there is the real, possibly size-guarded outcome; this outer `meta` is a raw, untransformed preview from the moment the sweep selected this trial's curve, and the two can legitimately differ.
+     */
+    url?: string;
+};
 /**
  * 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
@@ -752,6 +910,51 @@ type EquityPoint = {
  *
  */
 type StrategyId = string;
+/**
+ * One property name `POST /strategy` could establish without constructing the strategy —
+ * either declared with `@StrategyProperty` on the compiled source, or one of the small set of
+ * base properties every strategy carries (`amnt`, `enabled`, `multiEntry`, ...).
+ *
+ * **Best-effort, not exhaustive.** A property registered through an attached risk/backtest
+ * config needs a live instance to discover and is not listed here. Use this to catch a typo'd
+ * sweep key before submitting, not as the definitive list of what a sweep will accept — a
+ * name absent from this list may still be valid.
+ *
+ */
+type DeclaredProperty = {
+    /**
+     * The key a sweep or execute param map uses for this property.
+     */
+    name: string;
+    /**
+     * Human-readable label, as declared.
+     */
+    description?: string;
+    /**
+     * The declared default, as a string, if one was given. Absent, not null, when none was
+     * declared.
+     *
+     */
+    defaultValue?: string;
+    /**
+     * Whether a value for this key is injected into the strategy's field (`true`) or only
+     * available through the property map (`false`).
+     *
+     */
+    reflected?: boolean;
+    /**
+     * Suggested sweep/range minimum, if declared. Advisory only, never validated.
+     */
+    min?: number;
+    /**
+     * Suggested sweep/range maximum, if declared. Advisory only, never validated.
+     */
+    max?: number;
+    /**
+     * Suggested sweep/range step, if declared. Advisory only, never validated.
+     */
+    step?: number;
+};
 /**
  * A diagnostic the engine raised while the strategy ran. Advisory: it describes something worth
  * knowing about how the strategy is wired, not necessarily an error.
@@ -871,6 +1074,160 @@ type StrategyState = {
     validationStalled?: boolean;
     _links?: StrategyLinks;
 };
+/**
+ * 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.
+ *
+ */
+type Dataset = {
+    /**
+     * Opaque id, returned by `POST /datasets`.
+     */
+    datasetId: string;
+    /**
+     * Unique among your datasets.
+     */
+    name: string;
+    /**
+     * Always `ticker` in v1.
+     */
+    type: "ticker";
+    instrument: Instrument;
+    /**
+     * When the dataset was created.
+     */
+    createdAt: string;
+    /**
+     * The id of the most recently finalized, successfully ingested version. Absent until at
+     * least one upload has finished ingesting.
+     *
+     */
+    currentVersionId?: string;
+    /**
+     * When `currentVersionId` last changed. Absent until it has a value.
+     */
+    updatedAt?: string;
+    /**
+     * Start of `currentVersionId`'s own data range, as discovered at ingest time. Absent
+     * until a version exists.
+     *
+     */
+    from?: string;
+    /**
+     * End of `currentVersionId`'s own data range, as discovered at ingest time. Absent until
+     * a version exists.
+     *
+     */
+    to?: string;
+    /**
+     * `currentVersionId`'s own discovered bar cadence (e.g. `1s`, `1m`, `1h`). Absent until a
+     * version exists.
+     *
+     */
+    cadence?: string;
+};
+/**
+ * A `Dataset` plus a self link. Returned by `GET /datasets/{datasetId}`.
+ */
+type DatasetWithLinks = Dataset & {
+    _links?: {
+        self?: {
+            href?: string;
+        };
+    };
+};
+/**
+ * A `Dataset` plus the first upload session — the presigned URL to PUT the file to.
+ *
+ */
+type DatasetCreated = Dataset & {
+    /**
+     * Identifies this upload session. Pass to
+     * `POST /datasets/{datasetId}/uploads/{uploadId}/finalize` once the PUT completes.
+     *
+     */
+    uploadId: string;
+    upload: {
+        /**
+         * Presigned URL. `PUT` the raw CSV file here directly — no `Authorization`
+         * header, no other API credentials.
+         *
+         */
+        url: string;
+        /**
+         * How long `url` stays valid.
+         */
+        expiresInMinutes: number;
+    };
+};
+/**
+ * One successfully ingested upload. Cadence and timestamp unit are discovered from the file,
+ * not declared by the caller.
+ *
+ */
+type DatasetVersion = {
+    datasetId: string;
+    /**
+     * The version id. Pass as `datasetVersionId` on `POST .../prepare` to pin it.
+     */
+    id?: string;
+    /**
+     * Size of the uploaded file.
+     */
+    bytes?: number;
+    /**
+     * Number of data rows.
+     */
+    rows?: number;
+    /**
+     * The discovered bar cadence (e.g. `1s`, `1m`, `1h`).
+     */
+    cadence?: string;
+    /**
+     * The unit the `timestamp` column was uploaded in — ISO-8601, or the epoch band its
+     * numeric values fell in (seconds, millis, or micros).
+     *
+     */
+    timestampUnit?: "iso" | "s" | "ms" | "us";
+    /**
+     * Number of gaps at the discovered cadence.
+     */
+    gaps?: number;
+    /**
+     * The largest gap, in units of the discovered cadence step.
+     */
+    largestGapSteps?: number;
+};
+/**
+ * Progress of one upload, from staged through ingest. Postgres-backed 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}`.
+ *
+ */
+type DatasetUploadState = {
+    uploadId: string;
+    /**
+     * * `uploading` — the file was PUT to the presigned URL, but `finalize` has not been
+     * 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).
+     *
+     */
+    status: "uploading" | "ingesting" | "ready" | "failed";
+    /**
+     * The ingest job id, while `status` is `ingesting`.
+     */
+    jobId?: string;
+    /**
+     * Present when `status` is `ready` or `failed`.
+     */
+    version?: DatasetVersion;
+};
 type AuthTokenResponse = {
     /**
      * Short-lived HS256 JWT. Send as `Authorization: Bearer <token>` on all other endpoints.
@@ -1157,6 +1514,12 @@ type CompileStrategyResponses = {
      */
     200: {
         strategyId: StrategyId;
+        /**
+         * What could be established about this strategy's sweep-key vocabulary without
+         * constructing it. See `DeclaredProperty` — best-effort, not exhaustive.
+         *
+         */
+        declaredProperties?: Array<DeclaredProperty>;
     };
 };
 type CompileStrategyResponse = CompileStrategyResponses[keyof CompileStrategyResponses];
@@ -1288,7 +1651,9 @@ type PrepareBacktestData = {
     body: PrepareRequest;
     path: {
         /**
-         * ID of the exchange to prepare the backtesting for
+         * ID of the exchange to prepare the backtesting for (e.g. `binance`), or the reserved
+         * value `user` to prepare from a dataset you uploaded instead of a managed exchange.
+         *
          */
         exchangeId: string;
         /**
@@ -1302,17 +1667,23 @@ 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.
+     * 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.
      *
      */
     400: ResponseError;
     /**
-     * Exchange or data source type not found
+     * Exchange or data source type not found. For `exchangeId: user`, also returned when
+     * `datasetId` (or a pinned `datasetVersionId`) doesn't exist or isn't yours.
+     *
      */
     404: ResponseError;
     /**
      * Rate limited. Returned when the global queue exceeds capacity or the user has too many
-     * active backtests.
+     * active backtests. Does not apply to `exchangeId: user` — a dataset prepare reads an
+     * already-ingested file rather than enqueueing worker capacity.
      *
      */
     429: ResponseError;
@@ -1329,7 +1700,9 @@ type GetPrepareStatusData = {
     body?: never;
     path: {
         /**
-         * ID of the exchange for the backtesting process
+         * ID of the exchange for the backtesting process, or the reserved value `user` for a
+         * dataset-backed prepare.
+         *
          */
         exchangeId: string;
         /**
@@ -1490,6 +1863,48 @@ type GetSweepSensitivityResponses = {
     200: SweepSensitivity;
 };
 type GetSweepSensitivityResponse = GetSweepSensitivityResponses[keyof GetSweepSensitivityResponses];
+type GetSweepRunEquityCurveData = {
+    body?: never;
+    path: {
+        exchangeId: string;
+        type: DataSourceType;
+        requestId: string;
+        sweepId: string;
+        /**
+         * The trial's `runIx`, as it appears on its leaderboard row.
+         */
+        runIx: number;
+    };
+    query?: {
+        /**
+         * Requested JSON shape. Omit to use the sweep's submitted default; may be overridden either way by the server's size guard.
+         */
+        outMode?: EquityCurveOutMode;
+        /**
+         * Downsample to at most this many points (extrema-preserving — the global max/min and the exact first/last point are always kept). Omit to use the sweep's submitted default (itself omittable, for no downsampling).
+         */
+        resample?: number;
+        /**
+         * Delta-encode both fields from the second point onward. Omit to use the sweep's submitted default.
+         */
+        differential?: boolean;
+    };
+    url: "/backtest/{exchangeId}/{type}/executeSweep/{requestId}/{sweepId}/runs/{runIx}/equityCurve";
+};
+type GetSweepRunEquityCurveErrors = {
+    /**
+     * Sweep or `runIx` not found, or that trial's curve was never selected — indistinguishable from a caller's perspective.
+     */
+    404: ResponseError;
+};
+type GetSweepRunEquityCurveError = GetSweepRunEquityCurveErrors[keyof GetSweepRunEquityCurveErrors];
+type GetSweepRunEquityCurveResponses = {
+    /**
+     * The trial's equity curve, shaped per the resolved options.
+     */
+    200: EquityCurveResult;
+};
+type GetSweepRunEquityCurveResponse = GetSweepRunEquityCurveResponses[keyof GetSweepRunEquityCurveResponses];
 type ExecuteBacktestData = {
     /**
      * Execute task parameters
@@ -1506,10 +1921,13 @@ type ExecuteBacktestData = {
          *
          */
         storeSignals?: boolean;
+        equityCurve?: EquityCurveOptions;
     };
     path: {
         /**
-         * ID of the exchange for the backtesting process
+         * ID of the exchange for the backtesting process, or the reserved value `user` if
+         * `prepareJobId` came from a dataset-backed prepare.
+         *
          */
         exchangeId: string;
         /**
@@ -1624,6 +2042,179 @@ type GetBacktestResultResponses = {
     };
 };
 type GetBacktestResultResponse = GetBacktestResultResponses[keyof GetBacktestResultResponses];
+type ListDatasetsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/datasets";
+};
+type ListDatasetsResponses = {
+    /**
+     * Your datasets
+     */
+    200: {
+        datasets: Array<Dataset>;
+    };
+};
+type ListDatasetsResponse = ListDatasetsResponses[keyof ListDatasetsResponses];
+type CreateDatasetData = {
+    /**
+     * The dataset to create
+     */
+    body: {
+        /**
+         * A name unique among your datasets. `409` if already taken.
+         */
+        name: string;
+        instrument: Instrument;
+    };
+    path?: never;
+    query?: never;
+    url: "/datasets";
+};
+type CreateDatasetErrors = {
+    /**
+     * Invalid request, or `instrument` is not a plain spot pair
+     */
+    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 CreateDatasetError = CreateDatasetErrors[keyof CreateDatasetErrors];
+type CreateDatasetResponses = {
+    /**
+     * Dataset created, with an upload session ready for its first version
+     */
+    201: DatasetCreated;
+};
+type CreateDatasetResponse = CreateDatasetResponses[keyof CreateDatasetResponses];
+type DeleteDatasetData = {
+    body?: never;
+    path: {
+        /**
+         * The id returned by `POST /datasets`
+         */
+        datasetId: string;
+    };
+    query?: never;
+    url: "/datasets/{datasetId}";
+};
+type DeleteDatasetErrors = {
+    /**
+     * No such dataset for this user, or already deleted
+     */
+    404: ResponseError;
+};
+type DeleteDatasetError = DeleteDatasetErrors[keyof DeleteDatasetErrors];
+type DeleteDatasetResponses = {
+    /**
+     * Deleted
+     */
+    200: {
+        datasetId: string;
+        deleted: true;
+    };
+};
+type DeleteDatasetResponse = DeleteDatasetResponses[keyof DeleteDatasetResponses];
+type GetDatasetData = {
+    body?: never;
+    path: {
+        /**
+         * The id returned by `POST /datasets`
+         */
+        datasetId: string;
+    };
+    query?: never;
+    url: "/datasets/{datasetId}";
+};
+type GetDatasetErrors = {
+    /**
+     * No such dataset for this user
+     */
+    404: ResponseError;
+};
+type GetDatasetError = GetDatasetErrors[keyof GetDatasetErrors];
+type GetDatasetResponses = {
+    /**
+     * Dataset detail
+     */
+    200: DatasetWithLinks;
+};
+type GetDatasetResponse = GetDatasetResponses[keyof GetDatasetResponses];
+type FinalizeDatasetUploadData = {
+    body?: never;
+    path: {
+        /**
+         * The id returned by `POST /datasets`
+         */
+        datasetId: string;
+        /**
+         * The `uploadId` returned by `POST /datasets`
+         */
+        uploadId: string;
+    };
+    query?: never;
+    url: "/datasets/{datasetId}/uploads/{uploadId}/finalize";
+};
+type FinalizeDatasetUploadErrors = {
+    /**
+     * No such dataset for this user, or nothing was PUT to `upload.url` yet — a finalize with
+     * nothing to finalize.
+     *
+     */
+    404: ResponseError;
+    /**
+     * The uploaded file exceeds your tier's size limit for a dataset.
+     */
+    413: ResponseError;
+};
+type FinalizeDatasetUploadError = FinalizeDatasetUploadErrors[keyof FinalizeDatasetUploadErrors];
+type FinalizeDatasetUploadResponses = {
+    /**
+     * Ingest queued
+     */
+    202: {
+        jobId: string;
+    };
+};
+type FinalizeDatasetUploadResponse = FinalizeDatasetUploadResponses[keyof FinalizeDatasetUploadResponses];
+type GetDatasetUploadData = {
+    body?: never;
+    path: {
+        /**
+         * The id returned by `POST /datasets`
+         */
+        datasetId: string;
+        /**
+         * The `uploadId` returned by `POST /datasets`
+         */
+        uploadId: string;
+    };
+    query?: never;
+    url: "/datasets/{datasetId}/uploads/{uploadId}";
+};
+type GetDatasetUploadErrors = {
+    /**
+     * No such dataset for this user, or genuinely nothing is known about this `uploadId` — no
+     * version, no in-flight job, and nothing was ever PUT to its upload URL.
+     *
+     */
+    404: ResponseError;
+};
+type GetDatasetUploadError = GetDatasetUploadErrors[keyof GetDatasetUploadErrors];
+type GetDatasetUploadResponses = {
+    /**
+     * Current upload/ingest state
+     */
+    200: DatasetUploadState;
+};
+type GetDatasetUploadResponse = GetDatasetUploadResponses[keyof GetDatasetUploadResponses];
 type ClientOptions = {
     baseUrl: "https://api.qtsurfer.net/v1" | "https://api.qtsurfer.com/v1" | (string & {});
 };
@@ -1759,9 +2350,14 @@ declare const listStrategies: <ThrowOnError extends boolean = false>(options?: O
  * different means are two strategies, because deciding otherwise would mean deciding program
  * equivalence.
  *
+ * The response also lists `declaredProperties` — the sweep/execute param keys this strategy
+ * is known to accept, so a caller can catch a typo'd key before submitting a sweep instead of
+ * only learning it from a rejected one. See `DeclaredProperty`: best-effort, not exhaustive.
+ *
  */
 declare const compileStrategy: <ThrowOnError extends boolean = false>(options: Options<CompileStrategyData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
     strategyId: StrategyId;
+    declaredProperties?: Array<DeclaredProperty>;
 }, ResponseError, ThrowOnError>;
 /**
  * Check that a registered strategy can actually run
@@ -1829,6 +2425,11 @@ 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.
  *
+ * **`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
+ * two request shapes.
+ *
  */
 declare const prepareBacktest: <ThrowOnError extends boolean = false>(options: Options<PrepareBacktestData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AcceptedJob, ResponseError, ThrowOnError>;
 /**
@@ -1836,6 +2437,9 @@ declare const prepareBacktest: <ThrowOnError extends boolean = false>(options: O
  * Retrieves the current state of the prepare job identified by `jobId`.
  * Poll until `status` is `Completed`, `Failed`, or `Aborted`.
  *
+ * For a dataset prepare (`exchangeId: user`), coverage is reported against the dataset's own
+ * cadence grid instead of hours — see `cadence`/`gaps`/`largestGapSteps` on `PrepareJobState`.
+ *
  */
 declare const getPrepareStatus: <ThrowOnError extends boolean = false>(options: Options<GetPrepareStatusData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<PrepareJobState, ResponseError, ThrowOnError>;
 /**
@@ -1924,6 +2528,23 @@ declare const getSweepResult: <ThrowOnError extends boolean = false>(options: Op
  *
  */
 declare const getSweepSensitivity: <ThrowOnError extends boolean = false>(options: Options<GetSweepSensitivityData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<SweepSensitivity, ResponseError, ThrowOnError>;
+/**
+ * Get one sweep trial's equity curve
+ * The resource a leaderboard row's `equityCurve.url` points at — only reachable when that
+ * trial's curve was actually selected (`equityCurve.mode: topN` or `topPct` on the sweep
+ * submission, and this trial ranked among the winners). Returns the exact same
+ * `{points|timestamps+equities, meta}` shape a plain backtest's inline `equityCurve` carries.
+ *
+ * Query params reshape the response the same way a plain backtest's `equityCurve` options do.
+ * A param genuinely absent from the query string falls back to the `equityCurve` transform
+ * preference the sweep was submitted with — a param
+ * present but malformed does not fall back, it degrades the same way it always has. Above a
+ * server-side size threshold, the shape is forced regardless of either — `meta.outMode` in
+ * the response, not the query string or the submitted default, is the source of truth for
+ * what shape actually came back.
+ *
+ */
+declare const getSweepRunEquityCurve: <ThrowOnError extends boolean = false>(options: Options<GetSweepRunEquityCurveData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<EquityCurveResult, ResponseError, ThrowOnError>;
 /**
  * Execute a compiled strategy against a prepared dataset
  * Enqueues an execute task that runs the strategy identified by `strategyId` over the data
@@ -1933,8 +2554,12 @@ declare const getSweepSensitivity: <ThrowOnError extends boolean = false>(option
  * Returns immediately with a `jobId`; poll `GET /backtest/{exchangeId}/{type}/execute/{jobId}`
  * for the result.
  *
- * The same params (same `prepareJobId`, `strategyId`, `storeSignals`) always return the same
- * `jobId` (idempotent).
+ * The same params (same `prepareJobId`, `strategyId`, `storeSignals`, `equityCurve`) always
+ * return the same `jobId` (idempotent) — a request that omits `equityCurve` dedupes exactly
+ * as it did before that field existed.
+ *
+ * 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`.
  *
  */
 declare const executeBacktest: <ThrowOnError extends boolean = false>(options: Options<ExecuteBacktestData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AcceptedJob, ResponseError, ThrowOnError>;
@@ -1961,7 +2586,71 @@ declare const cancelBacktest: <ThrowOnError extends boolean = false>(options: Op
  *
  */
 declare const getBacktestResult: <ThrowOnError extends boolean = false>(options: Options<GetBacktestResultData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<GetBacktestResultResponse, ResponseError, ThrowOnError>;
+/**
+ * List your datasets
+ * Every dataset you have created and not deleted, most recently created first. Never a `404`
+ * — an empty array if you have none, same convention as `GET /strategies`.
+ *
+ */
+declare const listDatasets: <ThrowOnError extends boolean = false>(options?: Options<ListDatasetsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
+    datasets: Array<Dataset>;
+}, unknown, ThrowOnError>;
+/**
+ * Create a dataset and get a URL to upload it to
+ * Creates a dataset AND its first upload session in one call — a presigned URL your client
+ * PUTs the file to directly, no API credentials involved in that PUT. Call
+ * `POST /datasets/{datasetId}/uploads/{uploadId}/finalize` once the upload completes to kick
+ * off ingest.
+ *
+ * v1 is ticker data only — `type` is not a request field, it is always `"ticker"` in the
+ * 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.
+ *
+ */
+declare const createDataset: <ThrowOnError extends boolean = false>(options: Options<CreateDatasetData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DatasetCreated, ResponseError, ThrowOnError>;
+/**
+ * Delete a dataset
+ * Soft-delete — the dataset stops appearing in `GET /datasets`/`GET /datasets/{datasetId}` and
+ * can no longer be prepared from, but its object data is reclaimed later rather than purged
+ * inline, so a backtest already running against one of its versions is not disrupted.
+ *
+ */
+declare const deleteDataset: <ThrowOnError extends boolean = false>(options: Options<DeleteDatasetData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
+    datasetId: string;
+    deleted: true;
+}, ResponseError, ThrowOnError>;
+/**
+ * Get a dataset by id
+ * Detail for one dataset, plus a self link.
+ */
+declare const getDataset: <ThrowOnError extends boolean = false>(options: Options<GetDatasetData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DatasetWithLinks, ResponseError, ThrowOnError>;
+/**
+ * Finalize an uploaded file and start ingest
+ * Call once the file has been PUT to the `upload.url` from `POST /datasets`. Enqueues ingest
+ * and returns immediately; poll
+ * `GET /datasets/{datasetId}/uploads/{uploadId}` for the result.
+ *
+ * Idempotent — a repeat finalize of the same upload returns the same `jobId` rather than
+ * enqueueing a second ingest.
+ *
+ */
+declare const finalizeDatasetUpload: <ThrowOnError extends boolean = false>(options: Options<FinalizeDatasetUploadData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
+    jobId: string;
+}, ResponseError, ThrowOnError>;
+/**
+ * Get the state of an upload/ingest
+ * Poll after `POST .../finalize` until `status` is `ready` or `failed`. Also reports
+ * `uploading` (finalize not called yet, but the file was PUT) before you finalize at all.
+ *
+ */
+declare const getDatasetUpload: <ThrowOnError extends boolean = false>(options: Options<GetDatasetUploadData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<DatasetUploadState, 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 DataSourceType, 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 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 GetBacktestResultData, type GetBacktestResultError, type GetBacktestResultErrors, type GetBacktestResultResponse, type GetBacktestResultResponses, 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 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 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 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, deleteStrategy, downloadKlines, downloadTickers, executeBacktest, executeSweep, getBacktestResult, getPrepareStatus, getStrategy, getStrategyCode, getSweepResult, getSweepSensitivity, listExchanges, listInstruments, listSegmentInstruments, listStrategies, 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 DatasetUploadState, 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 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, prepareBacktest, validateStrategy };