solometrics 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,846 @@
+/** A price. Sent to the API as a string: `250`, `250.0` and `"250"` all become `"250"`. */
+type Amount = number | string | bigint;
+/** A shoe size, e.g. `10`, `"10.5"`, `"10W"`. */
+type Size = number | string;
+/** `"2026-01-01"` or a `Date` (formatted as its UTC calendar date). */
+type DateLike = string | Date;
+type QueryPrimitive = string | number | boolean | Date;
+type QueryValue = QueryPrimitive | readonly QueryPrimitive[] | null | undefined;
+type Query = Record<string, QueryValue>;
+/**
+ * A CSV for an upload endpoint:
+ *
+ * - a file path (`string`);
+ * - the CSV content as a `Uint8Array` / `Buffer` / `ArrayBuffer`;
+ * - a `Blob` or `File` (a `File`'s name is kept);
+ * - a Node readable stream (e.g. `fs.createReadStream(...)`), web `ReadableStream`, or any
+ *   async iterable of chunks;
+ * - `{ rows }`: objects that become CSV rows (header = union of keys, in first-seen order).
+ */
+type CsvSource = string | Uint8Array | ArrayBuffer | Blob | ReadableStream<Uint8Array> | AsyncIterable<Uint8Array | string> | {
+    rows: Iterable<CsvRow>;
+};
+type CsvRow = Record<string, unknown>;
+interface CsvFile {
+    name: string;
+    content: Uint8Array;
+}
+/**
+ * A listing to delete: a listing ID, a `[listingId, variantId]` tuple, or an
+ * object with `listingId`/`listing_id` and optional `variantId`/`variant_id`.
+ */
+type BatchDeleteItem = string | readonly [listingId: string, variantId?: string | null] | {
+    listingId: string;
+    variantId?: string | null;
+} | {
+    listing_id: string;
+    variant_id?: string | null;
+};
+
+/**
+ * Shapes of documented responses. Responses are plain objects parsed from JSON;
+ * these types only help editors and the type checker. Endpoints that pass
+ * StockX's own response through unchanged (catalog search, variant list,
+ * listing detail, ...) are typed as {@link StockXObject}.
+ */
+/** A JSON object passed through from StockX as received. */
+type StockXObject = Record<string, any>;
+interface InventorySku {
+    id: number;
+    retailer: string;
+    size: string;
+    retailer_sku: string;
+    supplier_sku: string | null;
+    title: string | null;
+    original_price: number | null;
+    price: number | null;
+    coupon_code_eligible: boolean | null;
+}
+interface InventoryProduct {
+    id: number;
+    style_color: string;
+    brand: string | null;
+    model_name: string | null;
+    gender: string | null;
+}
+/** `HIGH` | `MEDIUM` | `LOW` | `OOS` | `IN_STOCK` */
+type StockLevel = 'HIGH' | 'MEDIUM' | 'LOW' | 'OOS' | 'IN_STOCK' | (string & {});
+interface InventoryLocation {
+    location_code: string;
+    stock_level: StockLevel;
+    as_of: string;
+}
+interface InventoryItem {
+    sku: InventorySku;
+    product: InventoryProduct;
+    inventory: InventoryLocation[];
+}
+interface InventorySearchResponse {
+    total_skus: number;
+    count: number;
+    limit: number;
+    offset: number;
+    has_next_page: boolean;
+    items: InventoryItem[];
+}
+interface SkuHistoryRecord {
+    stock_level: StockLevel;
+    location: string;
+    record_created_at: string;
+    price: number | null;
+    original_price: number | null;
+    coupon_code_eligible: boolean | null;
+}
+interface SkuHistorySku {
+    retailer_sku: string;
+    size: string;
+    style_color: string;
+    model_name: string | null;
+    brand: string | null;
+}
+interface SkuHistoryResponse {
+    retailer: string;
+    cutoff_ts: string;
+    sku: SkuHistorySku;
+    history: SkuHistoryRecord[];
+    count: number;
+    limit: number | null;
+    has_more: boolean;
+}
+interface MarketVariant {
+    size: string;
+    lowestAsk: number | null;
+    highestBid: number | null;
+    lastSale: number | null;
+    currency: string;
+    highDemandPrice?: number | null;
+    productCondition?: string;
+    packagingCondition?: string;
+    regionId?: unknown;
+}
+interface MarketSearchResponse {
+    platform: 'stockx' | 'goat' | (string & {});
+    style_id: string;
+    fetched_at: string;
+    variants: MarketVariant[];
+}
+interface HotStylesResponse {
+    items: string[];
+    total: number;
+    page: number;
+    limit: number;
+    pages: number;
+    has_next: boolean;
+    has_prev: boolean;
+}
+interface OkResponse {
+    ok: boolean;
+}
+interface UploadJobResponse {
+    taskId: string;
+    status: string;
+    filename: string;
+    processedRows: number;
+    batchSize: number;
+    duplicateRowsRemoved?: number;
+}
+interface UploadValidationResponse {
+    filename: string;
+    total_rows: number;
+    valid_rows: number;
+    invalid_rows: number;
+    duplicate_rows: number;
+}
+interface UnlistJobResponse {
+    taskId: string;
+    status: string;
+    filename: string;
+    processedRows: number;
+    duplicateRowsRemoved: number;
+    resolveRows: number;
+}
+/** `PENDING` / `STARTED` / `PAUSED` while running; `SUCCESS` / `FAILURE` / `CANCELLED` when finished. */
+type JobState = 'PENDING' | 'STARTED' | 'PAUSED' | 'SUCCESS' | 'FAILURE' | 'CANCELLED' | (string & {});
+/**
+ * Background job progress. `result` holds job-specific progress counters
+ * (`null` until the job starts).
+ */
+interface JobStatus {
+    taskId: string;
+    status: JobState;
+    result: Record<string, unknown> | null;
+}
+interface UnmatchedResponse {
+    items: unknown[];
+}
+interface CancelUnlistResponse {
+    cancelled: boolean;
+    result: unknown;
+}
+interface TaskQueuedResponse {
+    taskId: string;
+    status: string;
+}
+interface CostRecord {
+    id: number;
+    style_id: string;
+    size: string;
+    variant_id: string;
+    cost: number;
+    is_active: boolean;
+    updated_at: string;
+}
+interface CostListResponse {
+    items: CostRecord[];
+    total: number;
+    page: number;
+    page_size: number;
+}
+interface CostImportResponse {
+    total_rows: number;
+    imported: number;
+    skipped: number;
+}
+interface CostClearResponse {
+    ok: boolean;
+    deleted: number;
+}
+interface OrderSyncResponse {
+    task_id: string;
+    status: string;
+}
+interface Order {
+    id: number;
+    order_number: string;
+    listing_id: string | null;
+    amount: number | null;
+    currency_code: string | null;
+    status: string | null;
+    inventory_type: string | null;
+    order_created_at: string | null;
+    order_updated_at: string | null;
+    product_id: string | null;
+    product_name: string | null;
+    style_id: string | null;
+    variant_id: string | null;
+    variant_name: string | null;
+    variant_value: string | null;
+    total_payout: number | null;
+    sale_price: number | null;
+    total_adjustments: number | null;
+    payout_currency: string | null;
+    auth_status: string | null;
+}
+interface OrderListResponse {
+    total: number;
+    page: number;
+    page_size: number;
+    orders: Order[];
+}
+interface OrderAnalyticsSummary {
+    total_orders: number;
+    total_revenue: number;
+    avg_payout: number;
+    total_fees: number;
+}
+interface TopProduct {
+    product_name: string;
+    style_id: string | null;
+    units_sold: number;
+    total_revenue: number;
+    avg_payout: number;
+}
+interface TopBrand {
+    brand: string;
+    units_sold: number;
+    total_revenue: number;
+}
+interface SalesTrendPoint {
+    period: string;
+    units: number;
+    revenue: number;
+}
+interface StatusCount {
+    status: string;
+    count: number;
+}
+interface OrderAnalyticsResponse {
+    summary: OrderAnalyticsSummary;
+    top_products: TopProduct[];
+    top_brands: TopBrand[];
+    sales_trend: SalesTrendPoint[];
+    status_breakdown: StatusCount[];
+}
+
+/** Options for endpoints that accept a StockX `connection_id`. */
+interface ConnectionOptions extends RequestOptions {
+    /** StockX connection to use. Defaults to the client's `connectionId`. */
+    connectionId?: number | null;
+}
+/** Options for the `waitFor*` job-polling helpers. */
+interface WaitOptions {
+    /** Milliseconds between status polls. Default 5000. */
+    pollInterval?: number;
+    /**
+     * Give up after this many milliseconds and throw {@link JobTimeoutError}.
+     * Without it, waits indefinitely.
+     */
+    timeout?: number | null;
+    /** Called with every status payload, including the final one. May return a promise. */
+    onProgress?: (status: JobStatus) => unknown;
+    /** Stop waiting; throws {@link APIUserAbortError}. */
+    signal?: AbortSignal | null;
+}
+declare abstract class APIResource {
+    protected readonly _client: Client;
+    constructor(client: Client);
+    protected _conn(connectionId: number | null | undefined): number | null;
+    protected _get<T>(path: string, query?: Query, options?: RequestOptions): Promise<T>;
+    protected _send<T>(method: HttpMethod, path: string, init?: {
+        query?: Query;
+        body?: unknown;
+        file?: CsvFile;
+    }, options?: RequestOptions): Promise<T>;
+    protected _wait(fetchStatus: (options: RequestOptions) => Promise<JobStatus>, taskId: string, { pollInterval, timeout, onProgress, signal }?: WaitOptions): Promise<JobStatus>;
+}
+
+declare class GoatMarketResource extends APIResource {
+    /**
+     * `GET /v2/goat/market/search` — per-size GOAT prices. Needs a linked GOAT
+     * account (`ConflictError` otherwise).
+     */
+    search(styleId: string, options?: RequestOptions): Promise<MarketSearchResponse>;
+}
+declare class GoatResource extends APIResource {
+    readonly market: GoatMarketResource;
+    constructor(client: Client);
+}
+
+interface InventoryFilters extends RequestOptions {
+    /** Broad search. */
+    q?: string;
+    /** Partial match. */
+    styleColor?: string;
+    /** Partial match. */
+    brand?: string;
+    /** Partial match. */
+    retailer?: string;
+    /** Exact match. */
+    size?: Size;
+    /** Partial match. */
+    retailerSku?: string;
+    /** Partial match. */
+    supplierSku?: string;
+}
+interface InventorySearchParams extends InventoryFilters {
+    /** Capped by your plan's `max_page_size`. */
+    limit?: number;
+    offset?: number;
+}
+interface InventoryIterParams extends InventoryFilters {
+    /** Page size for each request (the API's `limit`). */
+    pageSize?: number;
+    /** Start offset. Default 0. */
+    offset?: number;
+}
+interface SkuHistoryParams extends RequestOptions {
+    /** Look-back window in hours, 1–8760 (default 168). */
+    hours?: number;
+}
+/** Retailer inventory and SKU stock history. */
+declare class InventoryResource extends APIResource {
+    /** `GET /v1/inventory/search` — one page of SKUs with stock per location. */
+    search(params?: InventorySearchParams): Promise<InventorySearchResponse>;
+    /**
+     * Iterate every matching SKU across pages.
+     *
+     * Stops at the last page. Without provider access for `retailer` the plan's
+     * `max_page_number` cap applies, and going past it throws `BadRequestError`.
+     */
+    iterSearch(params?: InventoryIterParams): AsyncGenerator<InventoryItem, void, undefined>;
+    /**
+     * `GET /v1/reporting/retailers/{retailer}/skus/{retailerSku}/history` —
+     * stock history of one SKU, newest first.
+     */
+    history(retailer: string, retailerSku: string, params?: SkuHistoryParams): Promise<SkuHistoryResponse>;
+}
+
+interface CatalogSearchParams extends ConnectionOptions {
+    pageNumber?: number;
+    pageSize?: number;
+}
+interface CatalogVariantsParams extends ConnectionOptions {
+    /** Pass the style code so the product is cached for your account. */
+    styleId?: string;
+}
+declare class StockXCatalogResource extends APIResource {
+    /**
+     * `GET /v2/stockx/catalog/search` — StockX catalog search (usually by style
+     * code), returned as received from StockX.
+     */
+    search(q: string, params?: CatalogSearchParams): Promise<StockXObject>;
+    /**
+     * `GET /v2/stockx/catalog/products/{productId}/variants` — every size variant
+     * of a product, as received from StockX.
+     */
+    variants(productId: string, params?: CatalogVariantsParams): Promise<StockXObject[]>;
+}
+
+interface ListCostsParams extends ConnectionOptions {
+    page?: number;
+    /** 1–200, default 50. */
+    pageSize?: number;
+    /** Partial match. */
+    styleId?: string;
+}
+interface IterCostsParams extends ConnectionOptions {
+    /** Default 200. */
+    pageSize?: number;
+    styleId?: string;
+}
+interface UpdateCostParams extends ConnectionOptions {
+    cost?: number;
+    /** `false` keeps the record but excludes it from profit and smart pricing. */
+    isActive?: boolean;
+}
+/** Acquisition costs per style code / size / variant. Uses no StockX quota. */
+declare class StockXCostsResource extends APIResource {
+    /** `PATCH /v2/stockx/cost` — create or overwrite the cost for one style/size/variant. Basic plan. */
+    set(styleId: string, size: Size, variantId: string, cost: number, params?: ConnectionOptions): Promise<OkResponse>;
+    /** `GET /v2/stockx/costs` — cost records, newest first. */
+    list(params?: ListCostsParams): Promise<CostListResponse>;
+    /** Iterate every cost record across pages. */
+    iterList(params?: IterCostsParams): AsyncGenerator<CostRecord, void, undefined>;
+    /**
+     * `POST /v2/stockx/costs/import` — upsert costs from a CSV with
+     * `style_id, size, variant_id, cost`. Synchronous. Advanced plan.
+     */
+    importCsv(source: CsvSource, params?: ConnectionOptions): Promise<CostImportResponse>;
+    /** `PATCH /v2/stockx/costs/{costId}` — edit one record. Basic plan. */
+    update(costId: number, params?: UpdateCostParams): Promise<OkResponse>;
+    /** `DELETE /v2/stockx/costs` — delete EVERY cost record on the connection. Cannot be undone. Basic plan. */
+    clear(params?: ConnectionOptions): Promise<CostClearResponse>;
+}
+
+interface ListingFields extends ConnectionOptions {
+    currencyCode?: string;
+    /** ISO 8601 string or `Date`. */
+    expiresAt?: string | Date;
+    active?: boolean;
+    inventoryType?: string;
+}
+interface CreateBySkuParams extends ListingFields {
+    /** Acquisition cost, stored as a cost record for this style/size/variant. */
+    cost?: number;
+}
+interface CreateListingParams extends ListingFields {
+    /** Acquisition cost. Stored only together with `styleId` and `size`. */
+    cost?: number;
+    styleId?: string;
+    size?: Size;
+}
+interface UpdateListingParams extends ConnectionOptions {
+    amount?: Amount;
+    currencyCode?: string;
+    /** ISO 8601 string or `Date`. */
+    expiresAt?: string | Date;
+}
+interface ListListingsParams extends ConnectionOptions {
+    pageNumber?: number;
+    pageSize?: number;
+    /** Defaults to `ACTIVE` on the server; pass an array for several. */
+    listingStatuses?: string | readonly string[];
+    /** A style code already cached for your account (404 otherwise). */
+    sku?: string;
+}
+interface ActivateListingParams extends ConnectionOptions {
+    /** Relist at a new price. */
+    amount?: Amount;
+}
+interface DeleteListingParams extends ConnectionOptions {
+    /** Also delete the variant's cost records. */
+    variantId?: string;
+}
+interface UploadParams extends RequestOptions {
+    batchSize?: number;
+}
+/** Create, reprice and take down listings on your linked StockX account. */
+declare class StockXListingsResource extends APIResource {
+    /**
+     * `POST /v2/stockx/simple-listing` — list by style code and size.
+     *
+     * The backend resolves the variant. Throws `NotFoundError` if no variant
+     * matches and `ConflictError` when keep-listing mode skips it. Requires the
+     * basic plan.
+     */
+    createBySku(styleId: string, size: Size, amount: Amount, params?: CreateBySkuParams): Promise<StockXObject>;
+    /**
+     * `POST /v2/stockx/listings` — list a specific `variantId`.
+     *
+     * To store a cost record too, pass `cost`, `styleId` and `size` together (the
+     * API silently skips the cost if one is missing, so the SDK throws a
+     * `TypeError` instead). Requires the basic plan.
+     */
+    create(variantId: string, amount: Amount, params?: CreateListingParams): Promise<StockXObject>;
+    /** `PATCH /v2/stockx/listings/{listingId}` — reprice or change expiry. Requires the basic plan. */
+    update(listingId: string, params?: UpdateListingParams): Promise<StockXObject>;
+    /**
+     * `GET /v2/stockx/listings` — your listings, fetched live from StockX.
+     * ACTIVE listings carry `cost` and `netPrice`.
+     */
+    list(params?: ListListingsParams): Promise<StockXObject>;
+    /** `GET /v2/stockx/listings/{listingId}` — one listing. */
+    get(listingId: string, params?: ConnectionOptions): Promise<StockXObject>;
+    /**
+     * `GET /v2/stockx/listings/{listingId}/operations/{operationId}` — result of
+     * an asynchronous StockX operation.
+     */
+    getOperation(listingId: string, operationId: string, params?: ConnectionOptions): Promise<StockXObject>;
+    /** `PUT /v2/stockx/listings/{listingId}/deactivate` — take off market, keep the listing. Basic plan. */
+    deactivate(listingId: string, params?: ConnectionOptions): Promise<StockXObject>;
+    /**
+     * `PUT /v2/stockx/listings/{listingId}/activate` — put back on market,
+     * optionally at a new `amount`. Basic plan.
+     */
+    activate(listingId: string, params?: ActivateListingParams): Promise<StockXObject>;
+    /**
+     * `DELETE /v2/stockx/listings/{listingId}` — permanent. With `variantId` the
+     * variant's cost records are deleted too. Basic plan.
+     */
+    delete(listingId: string, params?: DeleteListingParams): Promise<StockXObject>;
+    /**
+     * `POST /v2/stockx/batch/delete-listing` — delete several listings in one
+     * StockX batch. Advanced plan.
+     *
+     * `items` may be listing ID strings, `[listingId, variantId]` tuples, or
+     * objects with `listingId`/`listing_id` and optional `variantId`/`variant_id`.
+     */
+    batchDelete(items: Iterable<BatchDeleteItem>, params?: ConnectionOptions): Promise<StockXObject>;
+    /**
+     * `POST /v2/stockx/listings/upload` — start a bulk listing job.
+     *
+     * Pass a CSV (path, bytes, Blob or stream) or `{ rows }` with
+     * `sku, size, quantity, amount, cost`. Returns a `taskId`; poll with
+     * {@link uploadStatus} or {@link waitForUpload}. Advanced plan.
+     */
+    upload(source: CsvSource, params?: UploadParams): Promise<UploadJobResponse>;
+    /**
+     * `POST /v2/stockx/listings/upload/validate` — count valid, invalid and
+     * duplicate rows without listing anything.
+     */
+    validateUpload(source: CsvSource, options?: RequestOptions): Promise<UploadValidationResponse>;
+    /** `GET /v2/stockx/listings/upload/{taskId}` */
+    uploadStatus(taskId: string, options?: RequestOptions): Promise<JobStatus>;
+    /**
+     * Poll {@link uploadStatus} until the job is SUCCESS, FAILURE or CANCELLED,
+     * and return the final status. Throws `JobTimeoutError` after `timeout` ms.
+     */
+    waitForUpload(taskId: string, options?: WaitOptions): Promise<JobStatus>;
+    /** `GET /v2/stockx/listings/upload/unmatched` — uploaded rows that could not be matched to a variant. */
+    unmatched(options?: RequestOptions): Promise<UnmatchedResponse>;
+    /**
+     * `POST /v2/stockx/listings/unlist` — start a bulk delist job.
+     *
+     * Rows carry `listing_id` (optionally `variant_id`), or `sku` (or `style_id`)
+     * plus `size` to match ACTIVE listings. Advanced plan.
+     */
+    unlist(source: CsvSource, options?: RequestOptions): Promise<UnlistJobResponse>;
+    /** `GET /v2/stockx/listings/unlist/{taskId}` */
+    unlistStatus(taskId: string, options?: RequestOptions): Promise<JobStatus>;
+    /** Poll {@link unlistStatus} until the job finishes. */
+    waitForUnlist(taskId: string, options?: WaitOptions): Promise<JobStatus>;
+    /** `POST /v2/stockx/listings/unlist/cancel` — cancel your running unlist job. */
+    cancelUnlist(options?: RequestOptions): Promise<CancelUnlistResponse>;
+    /**
+     * `POST /v2/stockx/listings/clear-all` — delete EVERY active listing in the
+     * account's `clear_all_scope`. Cannot be undone. Advanced plan.
+     */
+    clearAll(options?: RequestOptions): Promise<TaskQueuedResponse>;
+    /** `GET /v2/stockx/listings/clear-all/{taskId}` */
+    clearAllStatus(taskId: string, options?: RequestOptions): Promise<JobStatus>;
+    /** Poll {@link clearAllStatus} until the job finishes. */
+    waitForClearAll(taskId: string, options?: WaitOptions): Promise<JobStatus>;
+}
+
+interface MarketSearchParams extends RequestOptions {
+    size?: Size;
+    /** Skip the cache and spend StockX quota. */
+    force?: boolean;
+}
+interface HotStylesParams extends RequestOptions {
+    limit?: number;
+    page?: number;
+}
+interface HotStylesIterParams extends RequestOptions {
+    /** Default 100. */
+    pageSize?: number;
+}
+interface VariantMarketParams extends ConnectionOptions {
+    currencyCode?: string;
+}
+declare class StockXMarketResource extends APIResource {
+    /**
+     * `GET /v2/stockx/market/search` — lowest ask / highest bid per size.
+     *
+     * Served from cache when fresh; `force: true` skips the cache and spends
+     * StockX quota. Check `fetched_at` for freshness.
+     */
+    search(styleId: string, params?: MarketSearchParams): Promise<MarketSearchResponse>;
+    /** `GET /v2/stockx/market/hot` — style codes with recently cached quotes. */
+    hot(params?: HotStylesParams): Promise<HotStylesResponse>;
+    /** Iterate every recently quoted style code across pages. */
+    iterHot(params?: HotStylesIterParams): AsyncGenerator<string, void, undefined>;
+    /**
+     * `GET /v2/stockx/catalog/products/{productId}/variants/{variantId}/market-data`
+     *
+     * Live quote for one size. Always calls StockX. Returns StockX's market data
+     * object as received.
+     */
+    variant(productId: string, variantId: string, params?: VariantMarketParams): Promise<StockXObject>;
+}
+
+interface OrderFilters extends RequestOptions {
+    orderStatus?: string;
+    /** `"2026-01-01"` or a `Date` (its UTC calendar date). */
+    fromDate?: DateLike;
+    toDate?: DateLike;
+    search?: string;
+}
+interface ListOrdersParams extends OrderFilters {
+    page?: number;
+    pageSize?: number;
+}
+interface IterOrdersParams extends OrderFilters {
+    /** Default 200. */
+    pageSize?: number;
+}
+interface OrderAnalyticsParams extends RequestOptions {
+    fromDate?: DateLike;
+    toDate?: DateLike;
+    /** Default `monthly`. */
+    granularity?: 'daily' | 'weekly' | 'monthly';
+}
+/** Locally synced StockX orders. All endpoints need the advanced plan. */
+declare class StockXOrdersResource extends APIResource {
+    /**
+     * `POST /v2/stockx/orders/sync` — start a background sync from StockX. There
+     * is no status endpoint; query again later.
+     */
+    sync(options?: RequestOptions): Promise<OrderSyncResponse>;
+    /** `GET /v2/stockx/orders` — synced orders, newest first. */
+    list(params?: ListOrdersParams): Promise<OrderListResponse>;
+    /** Iterate every matching order across pages. */
+    iterList(params?: IterOrdersParams): AsyncGenerator<Order, void, undefined>;
+    /**
+     * `GET /v2/stockx/orders/analytics` — summary, top products/brands, sales
+     * trend and status breakdown.
+     */
+    analytics(params?: OrderAnalyticsParams): Promise<OrderAnalyticsResponse>;
+}
+
+declare class StockXResource extends APIResource {
+    readonly market: StockXMarketResource;
+    readonly catalog: StockXCatalogResource;
+    readonly listings: StockXListingsResource;
+    readonly costs: StockXCostsResource;
+    readonly orders: StockXOrdersResource;
+    constructor(client: Client);
+}
+
+/** A `fetch`-compatible function. */
+type Fetch = (url: string, init: RequestInit) => Promise<Response>;
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface ClientOptions {
+    /** Your `sr_live_...` key. Defaults to `process.env.SOLOMETRICS_API_KEY`. */
+    apiKey?: string;
+    /** Defaults to `process.env.SOLOMETRICS_BASE_URL` or `https://api.sneakers.itbanque.com`. */
+    baseURL?: string;
+    /** Per-attempt timeout in milliseconds, including reading the body. Default 60 000. `null` disables it. */
+    timeout?: number | null;
+    /**
+     * Retries for 429 (all methods), and for 502/503/504, timeouts and dropped
+     * connections on idempotent methods. Default 2. `0` disables.
+     */
+    maxRetries?: number;
+    /** Default StockX connection for endpoints that accept `connectionId`. Per-call values override it. */
+    connectionId?: number | null;
+    /** Extra headers sent with every request. */
+    defaultHeaders?: Record<string, string>;
+    /** Bring your own `fetch` (proxies, custom agents, instrumentation, ...). Defaults to `globalThis.fetch`. */
+    fetch?: Fetch;
+}
+/** Per-call options accepted by every API method. */
+interface RequestOptions {
+    /** Override the client's per-attempt timeout (milliseconds); `null` disables it. */
+    timeout?: number | null;
+    /** Override the client's `maxRetries`. */
+    maxRetries?: number;
+    /** Abort the request; throws {@link APIUserAbortError}. */
+    signal?: AbortSignal | null;
+    /** Extra headers for this request. */
+    headers?: Record<string, string>;
+}
+/** Options for the low-level {@link Client.get} / {@link Client.post} / ... methods. */
+interface RawRequestOptions extends RequestOptions {
+    query?: Query;
+    /** JSON body. */
+    body?: unknown;
+}
+/** @internal */
+interface FinalRequestOptions extends RequestOptions {
+    method: HttpMethod;
+    path: string;
+    query?: Query;
+    body?: unknown;
+    file?: CsvFile;
+}
+/**
+ * SneakersRadar API client.
+ *
+ * ```ts
+ * const client = new Client({ apiKey: 'sr_live_...' }); // or set SOLOMETRICS_API_KEY
+ * const quotes = await client.stockx.market.search('DZ5485-612');
+ * ```
+ *
+ * There is nothing to close: requests go through `fetch`.
+ */
+declare class Client {
+    #private;
+    readonly baseURL: string;
+    readonly timeout: number | null;
+    readonly maxRetries: number;
+    readonly connectionId: number | null;
+    readonly inventory: InventoryResource;
+    readonly stockx: StockXResource;
+    readonly goat: GoatResource;
+    constructor(options?: ClientOptions);
+    constructor(apiKey: string, options?: Omit<ClientOptions, 'apiKey'>);
+    get apiKey(): string;
+    /**
+     * Return a copy with some options changed. The copy shares `fetch` and the
+     * default headers. Pass `connectionId: null` to clear the default connection.
+     */
+    withOptions(options: Pick<ClientOptions, 'apiKey' | 'timeout' | 'maxRetries' | 'connectionId'>): Client;
+    /** Low-level GET for endpoints the SDK does not wrap yet. */
+    get<T = unknown>(path: string, options?: RawRequestOptions): Promise<T>;
+    post<T = unknown>(path: string, options?: RawRequestOptions): Promise<T>;
+    put<T = unknown>(path: string, options?: RawRequestOptions): Promise<T>;
+    patch<T = unknown>(path: string, options?: RawRequestOptions): Promise<T>;
+    delete<T = unknown>(path: string, options?: RawRequestOptions): Promise<T>;
+    /** @internal */
+    _request<T>(options: FinalRequestOptions): Promise<T>;
+    toString(): string;
+}
+
+/**
+ * Error hierarchy for the SneakersRadar API.
+ *
+ * Every non-2xx response throws a subclass of {@link APIStatusError}, chosen by
+ * status code. Network failures throw {@link APIConnectionError} (or its
+ * {@link APITimeoutError} subclass).
+ */
+/** Base class for every error thrown by this SDK. */
+declare class SolometricsError extends Error {
+    constructor(message?: string, options?: {
+        cause?: unknown;
+    });
+}
+/** An error talking to the API (network failure or non-2xx response). */
+declare class APIError extends SolometricsError {
+}
+/** The request never produced a response (DNS, TLS, connection reset, ...). */
+declare class APIConnectionError extends APIError {
+    constructor(message?: string, options?: {
+        cause?: unknown;
+    });
+}
+/** The request timed out on the client side. */
+declare class APITimeoutError extends APIConnectionError {
+    constructor(options?: {
+        cause?: unknown;
+    });
+}
+/** The caller's `AbortSignal` fired before the request (or job wait) finished. */
+declare class APIUserAbortError extends APIError {
+    constructor(options?: {
+        cause?: unknown;
+    });
+}
+/** One entry of a 422 `detail` list. */
+interface ValidationErrorItem {
+    loc?: (string | number)[];
+    msg?: string;
+    type?: string;
+    [key: string]: unknown;
+}
+/**
+ * The API returned a non-2xx status.
+ *
+ * - `status`: HTTP status code.
+ * - `detail`: the `detail` field of the JSON error body: a message string, or
+ *   a list of field errors for 422. `null` if the body had none.
+ * - `body`: the full decoded JSON body (or raw text if it was not JSON).
+ * - `headers`: the response headers.
+ */
+declare class APIStatusError extends APIError {
+    readonly status: number;
+    readonly detail: unknown;
+    readonly body: unknown;
+    readonly headers: Headers;
+    constructor(message: string, init: {
+        status: number;
+        headers: Headers;
+        body: unknown;
+    });
+}
+/**
+ * 400 — invalid request, plan pagination cap, bad CSV, no usable StockX
+ * connection, or the connection's daily request cap was reached.
+ */
+declare class BadRequestError extends APIStatusError {
+}
+/** 401 — the API key is missing, invalid or revoked. */
+declare class AuthenticationError extends APIStatusError {
+}
+/** 403 — the endpoint is not included in the account's plan. */
+declare class PermissionDeniedError extends APIStatusError {
+}
+/**
+ * 404 — style code, size, SKU or record not found (cost endpoints also return
+ * 404 when no StockX account is linked).
+ */
+declare class NotFoundError extends APIStatusError {
+}
+/** 409 — keep-listing mode skipped the listing, or a GOAT account is needed but not linked. */
+declare class ConflictError extends APIStatusError {
+}
+/** 422 — a parameter has the wrong type or is out of range. `errors` holds the field errors. */
+declare class UnprocessableEntityError extends APIStatusError {
+    get errors(): ValidationErrorItem[];
+}
+/** 429 — rate limit exceeded. `retryAfter` is the `Retry-After` header in seconds, when present. */
+declare class RateLimitError extends APIStatusError {
+    get retryAfter(): number | null;
+}
+/** 5xx not covered by a more specific class. */
+declare class InternalServerError extends APIStatusError {
+}
+/** 502 — the request to StockX/GOAT failed; `detail` carries the upstream error. */
+declare class UpstreamError extends InternalServerError {
+}
+/** 504 — StockX did not respond in time. */
+declare class UpstreamTimeoutError extends InternalServerError {
+}
+/**
+ * A `waitFor*` helper gave up before the background job finished.
+ * `lastStatus` is the last status payload seen.
+ */
+declare class JobTimeoutError extends SolometricsError {
+    readonly taskId: string;
+    readonly lastStatus: unknown;
+    constructor(taskId: string, lastStatus: unknown);
+}
+
+declare const VERSION = "0.1.0";
+
+export { APIConnectionError, APIError, APIStatusError, APITimeoutError, APIUserAbortError, type ActivateListingParams, type Amount, AuthenticationError, BadRequestError, type BatchDeleteItem, type CancelUnlistResponse, type CatalogSearchParams, type CatalogVariantsParams, Client, type ClientOptions, ConflictError, type ConnectionOptions, type CostClearResponse, type CostImportResponse, type CostListResponse, type CostRecord, type CreateBySkuParams, type CreateListingParams, type CsvRow, type CsvSource, type DateLike, type DeleteListingParams, type Fetch, GoatMarketResource, GoatResource, type HotStylesIterParams, type HotStylesParams, type HotStylesResponse, type HttpMethod, InternalServerError, type InventoryFilters, type InventoryItem, type InventoryIterParams, type InventoryLocation, type InventoryProduct, InventoryResource, type InventorySearchParams, type InventorySearchResponse, type InventorySku, type IterCostsParams, type IterOrdersParams, type JobState, type JobStatus, JobTimeoutError, type ListCostsParams, type ListListingsParams, type ListOrdersParams, type MarketSearchParams, type MarketSearchResponse, type MarketVariant, NotFoundError, type OkResponse, type Order, type OrderAnalyticsParams, type OrderAnalyticsResponse, type OrderAnalyticsSummary, type OrderFilters, type OrderListResponse, type OrderSyncResponse, PermissionDeniedError, type Query, type QueryValue, RateLimitError, type RawRequestOptions, type RequestOptions, type SalesTrendPoint, type Size, type SkuHistoryParams, type SkuHistoryRecord, type SkuHistoryResponse, type SkuHistorySku, SolometricsError, type StatusCount, type StockLevel, StockXCatalogResource, StockXCostsResource, StockXListingsResource, StockXMarketResource, type StockXObject, StockXOrdersResource, StockXResource, type TaskQueuedResponse, type TopBrand, type TopProduct, type UnlistJobResponse, type UnmatchedResponse, UnprocessableEntityError, type UpdateCostParams, type UpdateListingParams, type UploadJobResponse, type UploadParams, type UploadValidationResponse, UpstreamError, UpstreamTimeoutError, VERSION, type ValidationErrorItem, type VariantMarketParams, type WaitOptions };