@qtsurfer/api-client 0.9.0 → 0.11.0

package/dist/index.d.ts

@@ -63,6 +63,22 @@ type InstrumentLinks = {
      */
     futures?: HalLink;
 };
+/**
+ * HAL `_links` for a strategy — present on a full `StrategyState` body (`GET
+ * /strategy/{strategyId}`, and `POST /strategy/{strategyId}/validate`'s already-validated
+ * `200`), absent from that same endpoint's `202` — a deliberately partial stub carrying only
+ * what is known before a check has even started. Following `code` can still `404` once
+ * present: it documents its own honest "nothing to return" for a strategy with no source of
+ * its own (a `REFERENCE` marketplace copy, or one resolved only through the platform's shared
+ * pool). This link says where to look, not that something is there.
+ *
+ */
+type StrategyLinks = {
+    /**
+     * Link to this strategy's registered source, `GET /strategy/{strategyId}/code`.
+     */
+    code: HalLink;
+};
 /**
  * A HAL link object (Hypertext Application Language)
  */
@@ -153,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)
@@ -179,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
@@ -219,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 & {
@@ -237,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<{
         /**
@@ -762,6 +836,26 @@ type Notice = {
      */
     provenance?: "execute" | "compile-dry-run";
 };
+/**
+ * One entry from `GET /strategies` — the same provenance a full `StrategyState` carries
+ * (`compiledAt`, `requiredSources`), without its validation state, so listing stays cheap
+ * regardless of how many strategies you have registered. Check a specific strategy's
+ * validation with `GET /strategy/{strategyId}`.
+ *
+ */
+type StrategySummary = {
+    strategyId: StrategyId;
+    /**
+     * When the live compilation was produced.
+     */
+    compiledAt?: string;
+    /**
+     * The market data this strategy needs. Absent, not empty, when it could
+     * not be established without constructing the strategy.
+     *
+     */
+    requiredSources?: Array<string>;
+};
 /**
  * What is known about a registered strategy: that it compiled, and what validating it found.
  *
@@ -833,6 +927,161 @@ 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 (D-11).
+ *
+ */
+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 = {
     /**
@@ -1076,6 +1325,22 @@ type DownloadKlinesResponses = {
     200: Blob | File;
 };
 type DownloadKlinesResponse = DownloadKlinesResponses[keyof DownloadKlinesResponses];
+type ListStrategiesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/strategies";
+};
+type ListStrategiesResponses = {
+    /**
+     * Your registered strategies. An empty array if you have none — this is never a `404`.
+     *
+     */
+    200: {
+        strategies: Array<StrategySummary>;
+    };
+};
+type ListStrategiesResponse = ListStrategiesResponses[keyof ListStrategiesResponses];
 type CompileStrategyData = {
     /**
      * Raw strategy Java source code
@@ -1144,6 +1409,34 @@ type ValidateStrategyResponses = {
     202: StrategyState;
 };
 type ValidateStrategyResponse = ValidateStrategyResponses[keyof ValidateStrategyResponses];
+type DeleteStrategyData = {
+    body?: never;
+    path: {
+        /**
+         * The id returned by `POST /strategy`
+         */
+        strategyId: StrategyId;
+    };
+    query?: never;
+    url: "/strategy/{strategyId}";
+};
+type DeleteStrategyErrors = {
+    /**
+     * No such registered strategy for this user
+     */
+    404: ResponseError;
+};
+type DeleteStrategyError = DeleteStrategyErrors[keyof DeleteStrategyErrors];
+type DeleteStrategyResponses = {
+    /**
+     * Deleted
+     */
+    200: {
+        strategyId: StrategyId;
+        deleted: true;
+    };
+};
+type DeleteStrategyResponse = DeleteStrategyResponses[keyof DeleteStrategyResponses];
 type GetStrategyData = {
     body?: never;
     path: {
@@ -1169,6 +1462,37 @@ type GetStrategyResponses = {
     200: StrategyState;
 };
 type GetStrategyResponse = GetStrategyResponses[keyof GetStrategyResponses];
+type GetStrategyCodeData = {
+    body?: never;
+    path: {
+        /**
+         * The id returned by `POST /strategy`
+         */
+        strategyId: StrategyId;
+    };
+    query?: never;
+    url: "/strategy/{strategyId}/code";
+};
+type GetStrategyCodeErrors = {
+    /**
+     * No such registered strategy for this user, or nothing to read for this id
+     */
+    404: ResponseError;
+};
+type GetStrategyCodeError = GetStrategyCodeErrors[keyof GetStrategyCodeErrors];
+type GetStrategyCodeResponses = {
+    /**
+     * The registered source
+     */
+    200: {
+        strategyId: StrategyId;
+        /**
+         * Raw strategy Java source code, exactly as registered.
+         */
+        code: string;
+    };
+};
+type GetStrategyCodeResponse = GetStrategyCodeResponses[keyof GetStrategyCodeResponses];
 type PrepareBacktestData = {
     /**
      * The required data to prepare a backtesting
@@ -1176,7 +1500,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;
         /**
@@ -1190,17 +1516,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;
@@ -1217,7 +1549,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;
         /**
@@ -1397,7 +1731,9 @@ type ExecuteBacktestData = {
     };
     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;
         /**
@@ -1512,8 +1848,181 @@ 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.staging.qtsurfer.com/v1" | "https://api.qtsurfer.com/v1" | (string & {});
+    baseUrl: "https://api.qtsurfer.net/v1" | "https://api.qtsurfer.com/v1" | (string & {});
 };
 
 type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options$1<TData, ThrowOnError> & {
@@ -1610,6 +2119,19 @@ declare const downloadTickers: <ThrowOnError extends boolean = false>(options: O
  *
  */
 declare const downloadKlines: <ThrowOnError extends boolean = false>(options: Options<DownloadKlinesData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<Blob | File, ResponseError, ThrowOnError>;
+/**
+ * List your registered strategies
+ * Every strategy you have registered and not deleted, most recently compiled first.
+ *
+ * Each entry carries the same provenance `GET /strategy/{strategyId}` does — `compiledAt`,
+ * `requiredSources` — but not its validation state, so listing stays cheap regardless of how
+ * many strategies you have. Check a specific strategy's validation with `GET
+ * /strategy/{strategyId}`.
+ *
+ */
+declare const listStrategies: <ThrowOnError extends boolean = false>(options?: Options<ListStrategiesData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
+    strategies: Array<StrategySummary>;
+}, unknown, ThrowOnError>;
 /**
  * Compile and register a strategy
  * Compiles raw strategy source and registers it, returning its `strategyId`.
@@ -1653,6 +2175,24 @@ declare const compileStrategy: <ThrowOnError extends boolean = false>(options: O
  *
  */
 declare const validateStrategy: <ThrowOnError extends boolean = false>(options: Options<ValidateStrategyData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<StrategyState, ResponseError, ThrowOnError>;
+/**
+ * Release a registered strategy
+ * Removes a strategy from `GET /strategy/{strategyId}` and `GET /strategies`. This is not
+ * undone by re-submitting the same source to `POST /strategy` — that registers a new
+ * strategy, with a new id.
+ *
+ * **Backtests you already ran against this strategy are unaffected.** Deleting it stops it
+ * from counting against your account and stops you from validating or re-running it under
+ * this id — it does not erase what already happened.
+ *
+ * Only removes a strategy you registered yourself. If you copied someone else's strategy
+ * (a shared/marketplace listing), deleting your copy never affects theirs, or anyone else's.
+ *
+ */
+declare const deleteStrategy: <ThrowOnError extends boolean = false>(options: Options<DeleteStrategyData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
+    strategyId: StrategyId;
+    deleted: true;
+}, ResponseError, ThrowOnError>;
 /**
  * Get a strategy by id, including its validation state
  * Reports that the strategy is registered — implied by a `200` at all — and what validating it
@@ -1663,6 +2203,21 @@ declare const validateStrategy: <ThrowOnError extends boolean = false>(options:
  *
  */
 declare const getStrategy: <ThrowOnError extends boolean = false>(options: Options<GetStrategyData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<StrategyState, ResponseError, ThrowOnError>;
+/**
+ * Get a registered strategy's source, if you still have one to read
+ * The exact source you last submitted for this id — the same text `POST /strategy` derives
+ * `strategyId` from, whitespace and comments included.
+ *
+ * **"If available", not "always".** A strategy you resolve only through a shared/marketplace
+ * listing you copied by reference carries no source of its own, and reads as a `404` here the
+ * same as a `strategyId` you never registered — that is the honest answer either way, since
+ * from this endpoint's point of view nothing is there to return.
+ *
+ */
+declare const getStrategyCode: <ThrowOnError extends boolean = false>(options: Options<GetStrategyCodeData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
+    strategyId: StrategyId;
+    code: string;
+}, ResponseError, ThrowOnError>;
 /**
  * Prepare backtest data
  * Enqueues a prepare task over the requested date range. Returns immediately with a `jobId`;
@@ -1671,6 +2226,11 @@ declare const getStrategy: <ThrowOnError extends boolean = false>(options: Optio
  * 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>;
 /**
@@ -1678,6 +2238,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>;
 /**
@@ -1778,6 +2341,9 @@ declare const getSweepSensitivity: <ThrowOnError extends boolean = false>(option
  * The same params (same `prepareJobId`, `strategyId`, `storeSignals`) always return the same
  * `jobId` (idempotent).
  *
+ * 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>;
 /**
@@ -1803,7 +2369,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 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 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 Notice, type Options, type PrepareBacktestData, type PrepareBacktestError, type PrepareBacktestErrors, type PrepareBacktestResponse, type PrepareBacktestResponses, type PrepareJobState, type PrepareRequest, type ResponseError, type ResultMap, type StrategyId, type StrategyState, 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, downloadKlines, downloadTickers, executeBacktest, executeSweep, getBacktestResult, getPrepareStatus, getStrategy, getSweepResult, getSweepSensitivity, listExchanges, listInstruments, listSegmentInstruments, 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 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 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 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, getSweepSensitivity, listDatasets, listExchanges, listInstruments, listSegmentInstruments, listStrategies, prepareBacktest, validateStrategy };