@qtsurfer/api-client 0.1.0 → 0.1.1

package/README.md

@@ -1,5 +1,11 @@
 # @qtsurfer/api-client
 
+<p align="center">
+  <a href="https://github.com/QTSurfer/api-client-ts/actions/workflows/ci.yml"><img src="https://github.com/QTSurfer/api-client-ts/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://www.npmjs.com/package/@qtsurfer/api-client"><img src="https://img.shields.io/npm/v/@qtsurfer/api-client" alt="npm"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License"></a>
+</p>
+
 Auto-generated TypeScript API client for the [QTSurfer API](https://github.com/QTSurfer/qtsurfer-api), produced from the OpenAPI 3.1 spec with [`@hey-api/openapi-ts`](https://heyapi.dev/).
 
 This package is intentionally thin: one function per operation, 1:1 with the spec. For workflow orchestration (polling, retries, domain objects, unified errors), use [`@qtsurfer/sdk`](https://github.com/QTSurfer/sdk-ts).

package/dist/index.d.ts

@@ -1,3 +1,636 @@
-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. Currently only ticker is supported; kline and funding rate support is planned.
+ */
+type DataSourceType = 'ticker';
+/**
+ * Information about a single job
+ */
+type JobState = {
+    /**
+     * Unique context ID for the job
+     */
+    contextId: string;
+    /**
+     * Current status of the job
+     */
+    status: 'New' | 'Started' | '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 = {
+    /**
+     * Hostname of the worker node that executed the strategy
+     */
+    hostName?: string;
+    /**
+     * Instrument operations per second throughput during execution
+     */
+    iops?: number;
+    /**
+     * Redis key of the compiled strategy used for execution. Format: strategy:{userId}:ticker:{compilationId}
+     */
+    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 signal Parquet file. Format: {userId}/exec/{exchange}/{jobId}
+     */
+    signalsId?: string;
+    /**
+     * Public HTTPS URL to the Parquet file. Computed at setup time from publicBaseUrl + signalsId + .parquet. Available even before upload completes.
+     */
+    signalsUrl?: string;
+    /**
+     * Upload status. Done = file uploaded to R2. Failed = upload error (see signalsUploadReason). Skipped = no signals emitted or storage not configured.
+     */
+    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 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;
+    };
+    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>;
+/**
+ * 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 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, getExchanges, getExecutionResult, getInstruments, getPreparationStatus, getStrategyStatus, postStrategy, prepareBacktesting };