@qtsurfer/api-client 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,3 +1,811 @@
-export * from './generated';
-export { client } from './generated/client.gen';
-//# sourceMappingURL=index.d.ts.map
+import * as _hey_api_client_fetch from '@hey-api/client-fetch';
+import { TDataShape, Options as Options$1, Client } from '@hey-api/client-fetch';
+
+/**
+ * General response error
+ */
+type ResponseError = {
+    /**
+     * Status code
+     */
+    code: number;
+    /**
+     * Error description
+     */
+    message: string;
+};
+/**
+ * Exchange instrument identifier (e.g. a currency pair)
+ */
+type Instrument = string;
+/**
+ * Exchange instrument with data availability and market info
+ */
+type InstrumentDetail = {
+    /**
+     * Instrument identifier (e.g. currency pair)
+     */
+    id: string;
+    /**
+     * Base currency
+     */
+    base: string;
+    /**
+     * Quote currency
+     */
+    quote: string;
+    /**
+     * Earliest timestamp with quality-verified data available for backtesting
+     */
+    dataFrom?: string;
+    /**
+     * Latest timestamp with quality-verified data available for backtesting
+     */
+    dataTo?: string;
+    /**
+     * Last traded price
+     */
+    lastPrice?: number;
+    /**
+     * Trading volume in the last 24 hours (in quote currency)
+     */
+    volume24h?: number;
+};
+/**
+ * Exchange service provider
+ */
+type Exchange = {
+    /**
+     * Unique identifier for the exchange
+     */
+    id: string;
+    /**
+     * Name of the exchange
+     */
+    name: string;
+    /**
+     * Description of the exchange
+     */
+    description?: string;
+};
+/**
+ * Managed exchange data sources available for backtesting.
+ */
+type DataSourceType = 'ticker';
+/**
+ * Information about a single job
+ */
+type JobState = {
+    /**
+     * Opaque context identifier for the job
+     */
+    contextId: string;
+    /**
+     * Current status of the job. `Partial` (prepare only) means some
+     * hours are still being produced asynchronously — keep polling.
+     * Treat `Completed | Aborted | Failed` as terminal; anything else
+     * means keep polling.
+     *
+     */
+    status: 'New' | 'Started' | 'Partial' | 'Completed' | 'Aborted' | 'Failed';
+    /**
+     * Detailed status information, if available
+     */
+    statusDetail?: string | null;
+    /**
+     * Total size of the data being prepared
+     */
+    size: number;
+    /**
+     * The amount of data processed so far
+     */
+    completed: number;
+    /**
+     * Timestamp for when the preparation started
+     */
+    startTime?: string | null;
+    /**
+     * Timestamp for when the preparation finished
+     */
+    endTime?: string | null;
+};
+/**
+ * Response returned by async endpoints (`202 Accepted`). The `jobId` is deterministic for the
+ * same input parameters — repeated calls with identical params return the same id.
+ *
+ */
+type AcceptedJob = {
+    /**
+     * Unique job identifier; use this to poll for completion.
+     */
+    jobId: string;
+};
+/**
+ * Backtest job result.
+ */
+type BacktestJobResult = {
+    results: ResultMap;
+    state: JobState;
+};
+/**
+ * Execution result map. Always includes core fields (hostName, iops, strategyId, instrument). Yield metrics (pnlTotal, totalTrades, winRate, etc.) are present when the strategy emitted at least one trade. When signal storage is enabled, includes signal fields described below.
+ */
+type ResultMap = {
+    /**
+     * Identifier of the worker that executed the strategy. Useful when reporting issues so support can correlate with logs.
+     */
+    hostName?: string;
+    /**
+     * Instrument operations per second throughput during execution
+     */
+    iops?: number;
+    /**
+     * Identifier of the compiled strategy that produced this result
+     */
+    strategyId: string;
+    /**
+     * The instrument (currency pair) that was backtested
+     */
+    instrument: string;
+    /**
+     * Total profit and loss in the output currency
+     */
+    pnlTotal?: number;
+    /**
+     * Total number of trades executed by the strategy
+     */
+    totalTrades?: number;
+    /**
+     * Percentage of profitable trades (0-100)
+     */
+    winRate?: number;
+    /**
+     * Risk-adjusted return ratio (mean return / standard deviation of returns)
+     */
+    sharpeRatio?: number;
+    /**
+     * Downside risk-adjusted return ratio (mean return / downside deviation)
+     */
+    sortinoRatio?: number;
+    /**
+     * Compound Annual Growth Rate
+     */
+    cagr?: number;
+    /**
+     * Maximum absolute drawdown in the output currency
+     */
+    maxDrawdown?: number;
+    /**
+     * Maximum percentage drawdown from peak equity
+     */
+    maxDrawdownPercent?: number;
+    /**
+     * Number of signals emitted during strategy execution
+     */
+    signalCount?: number;
+    /**
+     * Storage key for the signals file. Treat as opaque; use signalsUrl to download.
+     */
+    signalsId?: string;
+    /**
+     * HTTPS URL to download the signals Parquet file. Use signalsUpload to know when it's ready.
+     */
+    signalsUrl?: string;
+    /**
+     * Upload status. Done = signal file is available at signalsUrl. Failed = upload error (see signalsUploadReason). Skipped = no signals emitted.
+     */
+    signalsUpload?: 'Done' | 'Failed' | 'Skipped';
+    /**
+     * ISO 8601 timestamp of when the upload completed. Only present when signalsUpload is Done.
+     */
+    signalsUploadedAt?: string;
+    /**
+     * Human-readable reason when signalsUpload is Failed or Skipped.
+     */
+    signalsUploadReason?: string;
+};
+/**
+ * Unique identifier for a compiled strategy
+ */
+type StrategyId = string;
+type GetExchangesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/exchanges';
+};
+type GetExchangesResponses = {
+    /**
+     * A JSON array of Exchanges
+     */
+    200: Array<Exchange>;
+};
+type GetExchangesResponse = GetExchangesResponses[keyof GetExchangesResponses];
+type GetInstrumentsData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the exchange to retrieve instruments for
+         */
+        exchangeId: string;
+    };
+    query?: never;
+    url: '/exchange/{exchangeId}/instruments';
+};
+type GetInstrumentsErrors = {
+    /**
+     * Exchange not found or instrument catalog not available
+     */
+    404: ResponseError;
+};
+type GetInstrumentsError = GetInstrumentsErrors[keyof GetInstrumentsErrors];
+type GetInstrumentsResponses = {
+    /**
+     * A JSON array of Instrument details with data availability
+     */
+    200: Array<InstrumentDetail>;
+};
+type GetInstrumentsResponse = GetInstrumentsResponses[keyof GetInstrumentsResponses];
+type GetExchangeTickersHourData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the exchange (e.g. `binance`).
+         */
+        exchangeId: string;
+        /**
+         * Base asset symbol (first leg of the pair).
+         */
+        base: string;
+        /**
+         * Quote asset symbol (second leg of the pair).
+         */
+        quote: string;
+    };
+    query: {
+        /**
+         * Hour selector in `YYYY-MM-DDTHH` (UTC). The returned segment covers
+         * `[HH:00:00Z, HH+1:00:00Z)`.
+         *
+         */
+        hour: string;
+        /**
+         * Response wire format. `lastra` (default) returns raw Lastra bytes.
+         * `parquet` returns Parquet via on-the-fly conversion using
+         * [lastra-convert](https://github.com/QTSurfer/lastra-convert).
+         *
+         */
+        format?: 'lastra' | 'parquet';
+    };
+    url: '/exchange/{exchangeId}/tickers/{base}/{quote}';
+};
+type GetExchangeTickersHourErrors = {
+    /**
+     * Missing or malformed parameters (e.g. `hour` not `YYYY-MM-DDTHH`).
+     */
+    400: ResponseError;
+    /**
+     * No Lastra segment exists for the requested instrument/hour.
+     */
+    404: ResponseError;
+    /**
+     * Unexpected I/O error serving the file.
+     */
+    500: ResponseError;
+};
+type GetExchangeTickersHourError = GetExchangeTickersHourErrors[keyof GetExchangeTickersHourErrors];
+type GetExchangeTickersHourResponses = {
+    /**
+     * One hour of tickers for the instrument. `Content-Type` is
+     * `application/vnd.lastra` by default or
+     * `application/vnd.apache.parquet` when `format=parquet` was
+     * requested.
+     *
+     */
+    200: Blob | File;
+};
+type GetExchangeTickersHourResponse = GetExchangeTickersHourResponses[keyof GetExchangeTickersHourResponses];
+type GetExchangeKlinesHourData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the exchange (e.g. `binance`).
+         */
+        exchangeId: string;
+        /**
+         * Base asset symbol.
+         */
+        base: string;
+        /**
+         * Quote asset symbol.
+         */
+        quote: string;
+    };
+    query: {
+        /**
+         * Hour selector in `YYYY-MM-DDTHH` (UTC). The returned segment covers
+         * `[HH:00:00Z, HH+1:00:00Z)`.
+         *
+         */
+        hour: string;
+        /**
+         * Response wire format. `lastra` (default) returns raw Lastra bytes.
+         * `parquet` returns Parquet via on-the-fly conversion.
+         *
+         */
+        format?: 'lastra' | 'parquet';
+    };
+    url: '/exchange/{exchangeId}/klines/{base}/{quote}';
+};
+type GetExchangeKlinesHourErrors = {
+    /**
+     * Missing or malformed parameters (e.g. `hour` not `YYYY-MM-DDTHH`).
+     */
+    400: ResponseError;
+    /**
+     * No Lastra segment exists for the requested instrument/hour.
+     */
+    404: ResponseError;
+    /**
+     * Unexpected I/O error serving the file.
+     */
+    500: ResponseError;
+};
+type GetExchangeKlinesHourError = GetExchangeKlinesHourErrors[keyof GetExchangeKlinesHourErrors];
+type GetExchangeKlinesHourResponses = {
+    /**
+     * One hour of klines for the instrument. `Content-Type` is
+     * `application/vnd.lastra` by default or
+     * `application/vnd.apache.parquet` when `format=parquet`.
+     *
+     */
+    200: Blob | File;
+};
+type GetExchangeKlinesHourResponse = GetExchangeKlinesHourResponses[keyof GetExchangeKlinesHourResponses];
+type PostStrategyData = {
+    /**
+     * Raw strategy Java source code
+     */
+    body: string;
+    headers?: {
+        /**
+         * When `true`, compile asynchronously and return `202` with a `jobId`.
+         */
+        'X-Compile-Async'?: boolean;
+    };
+    path?: never;
+    query?: never;
+    url: '/strategy';
+};
+type PostStrategyErrors = {
+    /**
+     * Invalid strategy (compilation error)
+     */
+    400: ResponseError;
+};
+type PostStrategyError = PostStrategyErrors[keyof PostStrategyErrors];
+type PostStrategyResponses = {
+    /**
+     * Strategy compiled successfully (sync mode)
+     */
+    200: {
+        strategyId: StrategyId;
+    };
+    /**
+     * Compile task accepted (async mode — set `X-Compile-Async: true`)
+     */
+    202: AcceptedJob;
+};
+type PostStrategyResponse = PostStrategyResponses[keyof PostStrategyResponses];
+type GetStrategyStatusData = {
+    body?: never;
+    path: {
+        /**
+         * The id returned by `POST /strategy` (sync) or the `jobId` returned in async mode
+         */
+        strategyId: string;
+    };
+    query?: never;
+    url: '/strategy/{strategyId}';
+};
+type GetStrategyStatusErrors = {
+    /**
+     * Strategy compile job not found
+     */
+    404: ResponseError;
+};
+type GetStrategyStatusError = GetStrategyStatusErrors[keyof GetStrategyStatusErrors];
+type GetStrategyStatusResponses = {
+    /**
+     * Strategy compile state
+     */
+    200: {
+        /**
+         * Compile job id (only set in async mode)
+         */
+        jobId?: string;
+        status: 'New' | 'Started' | 'Completed' | 'Aborted' | 'Failed';
+        strategyId?: StrategyId;
+        /**
+         * Compilation error messages when `status` is `Failed`
+         */
+        statusDetail?: string | null;
+    };
+};
+type GetStrategyStatusResponse = GetStrategyStatusResponses[keyof GetStrategyStatusResponses];
+type PrepareBacktestingData = {
+    /**
+     * The required data to prepare a backtesting
+     */
+    body: {
+        instrument: Instrument;
+        /**
+         * Start date for the preparation process. Supports the following formats:
+         * - ISO-8601 (e.g. 2024-12-14T23:59:59Z)
+         * - ISO DATE (e.g. 2024-12-14)
+         * - BASIC ISO DATE (e.g., 20241214)
+         *
+         */
+        from: string;
+        /**
+         * End date for the preparation process. Supports the following formats:
+         * - ISO-8601 (e.g. 2024-12-14T23:59:59Z)
+         * - ISO DATE (e.g. 2024-12-14)
+         * - BASIC ISO DATE (e.g., 20241214)
+         *
+         */
+        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`.
+         *
+         */
+        cadence?: '1s' | '5s' | '1m' | '5m' | '15m' | '1h' | '4h' | '1d';
+    };
+    path: {
+        /**
+         * ID of the exchange to prepare the backtesting for
+         */
+        exchangeId: string;
+        /**
+         * The type of data source to prepare from
+         */
+        type: DataSourceType;
+    };
+    query?: never;
+    url: '/backtest/{exchangeId}/{type}/prepare';
+};
+type PrepareBacktestingErrors = {
+    /**
+     * Invalid request or parameters. Also returned when `from` is older than the configured
+     * lookback window or `to` is in the future.
+     *
+     */
+    400: ResponseError;
+    /**
+     * Exchange or data source type not found
+     */
+    404: ResponseError;
+    /**
+     * Rate limited. Returned when the global queue exceeds capacity or the user has too many
+     * active backtests.
+     *
+     */
+    429: ResponseError;
+};
+type PrepareBacktestingError = PrepareBacktestingErrors[keyof PrepareBacktestingErrors];
+type PrepareBacktestingResponses = {
+    /**
+     * Prepare task accepted (queued for processing)
+     */
+    202: AcceptedJob;
+};
+type PrepareBacktestingResponse = PrepareBacktestingResponses[keyof PrepareBacktestingResponses];
+type GetPreparationStatusData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the exchange for the backtesting process
+         */
+        exchangeId: string;
+        /**
+         * The type of data source to prepare from
+         */
+        type: DataSourceType;
+        /**
+         * Job ID returned by `POST /prepare`
+         */
+        jobId: string;
+    };
+    query?: never;
+    url: '/backtest/{exchangeId}/{type}/prepare/{jobId}';
+};
+type GetPreparationStatusErrors = {
+    /**
+     * Invalid request or parameters
+     */
+    400: ResponseError;
+    /**
+     * Prepare job not found or expired
+     */
+    404: ResponseError;
+};
+type GetPreparationStatusError = GetPreparationStatusErrors[keyof GetPreparationStatusErrors];
+type GetPreparationStatusResponses = {
+    /**
+     * Current prepare job state
+     */
+    200: JobState;
+};
+type GetPreparationStatusResponse = GetPreparationStatusResponses[keyof GetPreparationStatusResponses];
+type ExecuteBacktestingData = {
+    /**
+     * Execute task parameters
+     */
+    body: {
+        /**
+         * Job ID returned by `POST /prepare` (must be in `Completed` state)
+         */
+        prepareJobId: string;
+        strategyId: StrategyId;
+        /**
+         * When true, the worker uploads emitted signals to object storage and the
+         * response includes `signalsUrl` / `signalsId` fields. Defaults to false.
+         *
+         */
+        storeSignals?: boolean;
+    };
+    path: {
+        /**
+         * ID of the exchange for the backtesting process
+         */
+        exchangeId: string;
+        /**
+         * The type of data source to execute from
+         */
+        type: DataSourceType;
+    };
+    query?: never;
+    url: '/backtest/{exchangeId}/{type}/execute';
+};
+type ExecuteBacktestingErrors = {
+    /**
+     * Invalid request or parameters
+     */
+    400: ResponseError;
+    /**
+     * Prepare job not found or expired
+     */
+    404: ResponseError;
+    /**
+     * Rate limited (global queue at capacity or per-user limit reached)
+     */
+    429: ResponseError;
+};
+type ExecuteBacktestingError = ExecuteBacktestingErrors[keyof ExecuteBacktestingErrors];
+type ExecuteBacktestingResponses = {
+    /**
+     * Execute task accepted (queued for processing)
+     */
+    202: AcceptedJob;
+};
+type ExecuteBacktestingResponse = ExecuteBacktestingResponses[keyof ExecuteBacktestingResponses];
+type CancelExecutionData = {
+    body?: never;
+    path: {
+        exchangeId: string;
+        type: DataSourceType;
+        /**
+         * Job ID returned by `POST /execute`
+         */
+        jobId: string;
+    };
+    query?: never;
+    url: '/backtest/{exchangeId}/{type}/execute/{jobId}';
+};
+type CancelExecutionErrors = {
+    /**
+     * Execution not found
+     */
+    404: ResponseError;
+};
+type CancelExecutionError = CancelExecutionErrors[keyof CancelExecutionErrors];
+type CancelExecutionResponses = {
+    /**
+     * Cancellation request accepted
+     */
+    200: {
+        status?: 'cancelling';
+        jobId?: string;
+    };
+};
+type CancelExecutionResponse = CancelExecutionResponses[keyof CancelExecutionResponses];
+type GetExecutionResultData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the exchange for the backtesting process
+         */
+        exchangeId: string;
+        /**
+         * The type of data source to execute from
+         */
+        type: DataSourceType;
+        /**
+         * Job ID returned by `POST /execute`
+         */
+        jobId: string;
+    };
+    query?: never;
+    url: '/backtest/{exchangeId}/{type}/execute/{jobId}';
+};
+type GetExecutionResultErrors = {
+    /**
+     * Invalid request or parameters
+     */
+    400: ResponseError;
+    /**
+     * Execution job not found
+     */
+    404: ResponseError;
+};
+type GetExecutionResultError = GetExecutionResultErrors[keyof GetExecutionResultErrors];
+type GetExecutionResultResponses = {
+    /**
+     * Backtesting execution result
+     */
+    200: BacktestJobResult;
+};
+type GetExecutionResultResponse = GetExecutionResultResponses[keyof GetExecutionResultResponses];
+type ClientOptions = {
+    baseUrl: 'https://api.staging.qtsurfer.com/v1' | 'https://api.qtsurfer.com/v1' | (string & {});
+};
+
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options$1<TData, ThrowOnError> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+/**
+ * Get a list of available exchanges
+ */
+declare const getExchanges: <ThrowOnError extends boolean = false>(options?: Options<GetExchangesData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<Exchange[], unknown, ThrowOnError>;
+/**
+ * Get a list of Instruments from a specific exchange
+ */
+declare const getInstruments: <ThrowOnError extends boolean = false>(options: Options<GetInstrumentsData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<InstrumentDetail[], ResponseError, ThrowOnError>;
+/**
+ * Download one hour of tickers for an instrument as a Lastra segment
+ * Serves exactly one hour of raw ticker data for the given instrument on the
+ * requested exchange. The payload is a native [Lastra](https://github.com/QTSurfer/lastra-java)
+ * file — QTSurfer's columnar format for tick-precision timeseries — with
+ * no JSON envelope.
+ *
+ * One segment = one hour, aligned to UTC. The `hour` query parameter selects
+ * the segment and must match `YYYY-MM-DDTHH` (no minutes/seconds, no timezone
+ * suffix). Example: `hour=2026-01-15T10` returns `h10.lastra` for
+ * 2026-01-15, covering `[10:00:00Z, 11:00:00Z)`. Hours not yet available
+ * return `404`.
+ *
+ * A `format=parquet` query parameter switches the response to on-the-fly
+ * Parquet conversion via [lastra-convert](https://github.com/QTSurfer/lastra-convert)
+ * for clients that don't yet read Lastra. Lastra is the primary format
+ * and cheaper when the client can consume it.
+ *
+ * Clients:
+ * - [lastra-java](https://github.com/QTSurfer/lastra-java) — reference
+ * Java reader/writer with per-column codecs (ALP, Gorilla, delta-varint,
+ * ZSTD) and CRC32 integrity.
+ * - [lastra-ts](https://github.com/QTSurfer/lastra-ts) — TypeScript reader
+ * (~4 kB bundle, browser + Node.js).
+ * - [duckdb-lastra](https://github.com/QTSurfer/duckdb-lastra) — DuckDB
+ * extension for ad-hoc SQL over Lastra files.
+ * - [lastra-convert](https://github.com/QTSurfer/lastra-convert) — CLI + Java
+ * API for converting to/from Parquet, Reef, and CSV.
+ * - `curl -OJ` for offline dumps (the `Content-Disposition` header sets a
+ * descriptive filename).
+ *
+ */
+declare const getExchangeTickersHour: <ThrowOnError extends boolean = false>(options: Options<GetExchangeTickersHourData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<Blob | File, ResponseError, ThrowOnError>;
+/**
+ * Download one hour of klines for an instrument as a Lastra segment
+ * Same shape and semantics as `/exchange/{exchangeId}/tickers/{base}/{quote}`,
+ * but serves klines (aggregated bars) instead of raw ticks. One
+ * [Lastra](https://github.com/QTSurfer/lastra-java) segment = one hour of
+ * klines at the exchange's native kline cadence, aligned to UTC.
+ *
+ * Klines use the same columnar layout as tickers — readers that handle one
+ * format read the other with the same code. Use this endpoint when a
+ * per-tick payload would be too large for the window of interest.
+ *
+ */
+declare const getExchangeKlinesHour: <ThrowOnError extends boolean = false>(options: Options<GetExchangeKlinesHourData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<Blob | File, ResponseError, ThrowOnError>;
+/**
+ * Compile a strategy from source code
+ * Submits raw strategy source for compilation. By default the call is synchronous and returns
+ * the `strategyId` once compilation succeeds. Set the header `X-Compile-Async: true` to enqueue
+ * the compile task and return immediately with a `jobId` — poll
+ * `GET /strategy/{strategyId}` to check status.
+ *
+ * The `strategyId` is deterministic: the same source for the same user always produces the
+ * same id.
+ *
+ */
+declare const postStrategy: <ThrowOnError extends boolean = false>(options: Options<PostStrategyData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<PostStrategyResponse, ResponseError, ThrowOnError>;
+/**
+ * Get the status of an async compile task
+ * Polls the status of a strategy compilation. Useful when the strategy was submitted with
+ * `X-Compile-Async: true`. Returns the resolved `strategyId` once compilation completes.
+ *
+ */
+declare const getStrategyStatus: <ThrowOnError extends boolean = false>(options: Options<GetStrategyStatusData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
+    jobId?: string;
+    status: "New" | "Started" | "Completed" | "Aborted" | "Failed";
+    strategyId?: StrategyId;
+    statusDetail?: string | null;
+}, ResponseError, ThrowOnError>;
+/**
+ * Prepare backtesting data
+ * Enqueues a prepare task over the requested date range. Returns immediately with a `jobId`;
+ * poll `GET /backtest/{exchangeId}/{type}/prepare/{jobId}` for completion.
+ *
+ * The same params always return the same `jobId` (idempotent). Repeated calls with identical
+ * params do not enqueue duplicate work — they reuse the existing job.
+ *
+ */
+declare const prepareBacktesting: <ThrowOnError extends boolean = false>(options: Options<PrepareBacktestingData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AcceptedJob, ResponseError, ThrowOnError>;
+/**
+ * Get the status of a prepare job
+ * Retrieves the current state of the prepare job identified by `jobId`.
+ * Poll until `status` is `Completed`, `Failed`, or `Aborted`.
+ *
+ */
+declare const getPreparationStatus: <ThrowOnError extends boolean = false>(options: Options<GetPreparationStatusData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<JobState, ResponseError, ThrowOnError>;
+/**
+ * Execute a compiled strategy against a prepared dataset
+ * Enqueues an execute task that runs the strategy identified by `strategyId` over the data
+ * prepared by the prepare job identified by `prepareJobId`. The instrument and date range are
+ * recovered from the prepare job — they do not need to be sent again.
+ *
+ * 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).
+ *
+ */
+declare const executeBacktesting: <ThrowOnError extends boolean = false>(options: Options<ExecuteBacktestingData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<AcceptedJob, ResponseError, ThrowOnError>;
+/**
+ * Cancel a running backtest execution
+ * Requests cancellation of the specified execution. The execution
+ * status will transition to `Aborted` once the cancellation is
+ * processed. Cancellation is asynchronous — poll the GET endpoint
+ * to confirm the final status.
+ *
+ */
+declare const cancelExecution: <ThrowOnError extends boolean = false>(options: Options<CancelExecutionData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<{
+    status?: "cancelling";
+    jobId?: string;
+}, ResponseError, ThrowOnError>;
+/**
+ * Get the result of a backtest execution job
+ * Retrieves the current state and results of the execute job identified by `jobId`.
+ * Poll until `state.status` is `Completed`, `Failed`, or `Aborted`.
+ *
+ */
+declare const getExecutionResult: <ThrowOnError extends boolean = false>(options: Options<GetExecutionResultData, ThrowOnError>) => _hey_api_client_fetch.RequestResult<BacktestJobResult, ResponseError, ThrowOnError>;
+
+declare const client: _hey_api_client_fetch.Client;
+
+export { type AcceptedJob, type BacktestJobResult, type CancelExecutionData, type CancelExecutionError, type CancelExecutionErrors, type CancelExecutionResponse, type CancelExecutionResponses, type ClientOptions, type DataSourceType, type Exchange, type ExecuteBacktestingData, type ExecuteBacktestingError, type ExecuteBacktestingErrors, type ExecuteBacktestingResponse, type ExecuteBacktestingResponses, type GetExchangeKlinesHourData, type GetExchangeKlinesHourError, type GetExchangeKlinesHourErrors, type GetExchangeKlinesHourResponse, type GetExchangeKlinesHourResponses, type GetExchangeTickersHourData, type GetExchangeTickersHourError, type GetExchangeTickersHourErrors, type GetExchangeTickersHourResponse, type GetExchangeTickersHourResponses, type GetExchangesData, type GetExchangesResponse, type GetExchangesResponses, type GetExecutionResultData, type GetExecutionResultError, type GetExecutionResultErrors, type GetExecutionResultResponse, type GetExecutionResultResponses, type GetInstrumentsData, type GetInstrumentsError, type GetInstrumentsErrors, type GetInstrumentsResponse, type GetInstrumentsResponses, type GetPreparationStatusData, type GetPreparationStatusError, type GetPreparationStatusErrors, type GetPreparationStatusResponse, type GetPreparationStatusResponses, type GetStrategyStatusData, type GetStrategyStatusError, type GetStrategyStatusErrors, type GetStrategyStatusResponse, type GetStrategyStatusResponses, type Instrument, type InstrumentDetail, type JobState, type Options, type PostStrategyData, type PostStrategyError, type PostStrategyErrors, type PostStrategyResponse, type PostStrategyResponses, type PrepareBacktestingData, type PrepareBacktestingError, type PrepareBacktestingErrors, type PrepareBacktestingResponse, type PrepareBacktestingResponses, type ResponseError, type ResultMap, type StrategyId, cancelExecution, client, executeBacktesting, getExchangeKlinesHour, getExchangeTickersHour, getExchanges, getExecutionResult, getInstruments, getPreparationStatus, getStrategyStatus, postStrategy, prepareBacktesting };