solometrics 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1163 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIConnectionError: () => APIConnectionError,
+  APIError: () => APIError,
+  APIStatusError: () => APIStatusError,
+  APITimeoutError: () => APITimeoutError,
+  APIUserAbortError: () => APIUserAbortError,
+  AuthenticationError: () => AuthenticationError,
+  BadRequestError: () => BadRequestError,
+  Client: () => Client,
+  ConflictError: () => ConflictError,
+  GoatMarketResource: () => GoatMarketResource,
+  GoatResource: () => GoatResource,
+  InternalServerError: () => InternalServerError,
+  InventoryResource: () => InventoryResource,
+  JobTimeoutError: () => JobTimeoutError,
+  NotFoundError: () => NotFoundError,
+  PermissionDeniedError: () => PermissionDeniedError,
+  RateLimitError: () => RateLimitError,
+  SolometricsError: () => SolometricsError,
+  StockXCatalogResource: () => StockXCatalogResource,
+  StockXCostsResource: () => StockXCostsResource,
+  StockXListingsResource: () => StockXListingsResource,
+  StockXMarketResource: () => StockXMarketResource,
+  StockXOrdersResource: () => StockXOrdersResource,
+  StockXResource: () => StockXResource,
+  UnprocessableEntityError: () => UnprocessableEntityError,
+  UpstreamError: () => UpstreamError,
+  UpstreamTimeoutError: () => UpstreamTimeoutError,
+  VERSION: () => VERSION
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SolometricsError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var APIError = class extends SolometricsError {
+};
+var APIConnectionError = class extends APIError {
+  constructor(message = "Connection error.", options) {
+    super(message, options);
+  }
+};
+var APITimeoutError = class extends APIConnectionError {
+  constructor(options) {
+    super("Request timed out.", options);
+  }
+};
+var APIUserAbortError = class extends APIError {
+  constructor(options) {
+    super("Request was aborted.", options);
+  }
+};
+var APIStatusError = class extends APIError {
+  status;
+  detail;
+  body;
+  headers;
+  constructor(message, init) {
+    super(`${init.status}: ${message}`);
+    this.status = init.status;
+    this.headers = init.headers;
+    this.body = init.body;
+    this.detail = isRecord(init.body) && "detail" in init.body ? init.body.detail : null;
+  }
+};
+var BadRequestError = class extends APIStatusError {
+};
+var AuthenticationError = class extends APIStatusError {
+};
+var PermissionDeniedError = class extends APIStatusError {
+};
+var NotFoundError = class extends APIStatusError {
+};
+var ConflictError = class extends APIStatusError {
+};
+var UnprocessableEntityError = class extends APIStatusError {
+  get errors() {
+    return Array.isArray(this.detail) ? this.detail : [];
+  }
+};
+var RateLimitError = class extends APIStatusError {
+  get retryAfter() {
+    return parseRetryAfter(this.headers);
+  }
+};
+var InternalServerError = class extends APIStatusError {
+};
+var UpstreamError = class extends InternalServerError {
+};
+var UpstreamTimeoutError = class extends InternalServerError {
+};
+var JobTimeoutError = class extends SolometricsError {
+  taskId;
+  lastStatus;
+  constructor(taskId, lastStatus) {
+    const status = isRecord(lastStatus) ? lastStatus.status : lastStatus;
+    super(`Job ${taskId} did not finish in time (last status: ${String(status)})`);
+    this.taskId = taskId;
+    this.lastStatus = lastStatus;
+  }
+};
+var STATUS_MAP = {
+  400: BadRequestError,
+  401: AuthenticationError,
+  403: PermissionDeniedError,
+  404: NotFoundError,
+  409: ConflictError,
+  422: UnprocessableEntityError,
+  429: RateLimitError,
+  502: UpstreamError,
+  504: UpstreamTimeoutError
+};
+function parseRetryAfter(headers) {
+  const raw = headers.get("retry-after");
+  if (raw === null || raw.trim() === "") return null;
+  const value = Number(raw);
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function makeStatusError(status, statusText, headers, text) {
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = text || null;
+  }
+  const detail = isRecord(body) ? body.detail : void 0;
+  let message;
+  if (typeof detail === "string") {
+    message = detail;
+  } else if (Array.isArray(detail)) {
+    const parts = detail.map((err) => {
+      if (isRecord(err)) {
+        const loc = Array.isArray(err.loc) ? err.loc.map(String).join(".") : "";
+        return loc ? `${loc}: ${String(err.msg)}` : String(err.msg);
+      }
+      return String(err);
+    });
+    message = parts.join("; ") || "Validation error";
+  } else if (typeof body === "string" && body) {
+    message = body.slice(0, 500);
+  } else {
+    message = statusText || "API error";
+  }
+  const cls = STATUS_MAP[status] ?? (status >= 500 ? InternalServerError : APIStatusError);
+  return new cls(message, { status, headers, body });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core.ts
+var DEFAULT_BASE_URL = "https://api.sneakers.itbanque.com";
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var API_KEY_ENV = "SOLOMETRICS_API_KEY";
+var BASE_URL_ENV = "SOLOMETRICS_BASE_URL";
+var TERMINAL_JOB_STATUSES = /* @__PURE__ */ new Set(["SUCCESS", "FAILURE", "CANCELLED"]);
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "PATCH", "DELETE"]);
+var MAX_BACKOFF_MS = 8e3;
+var MAX_RETRY_AFTER_MS = 6e4;
+function readEnv(name) {
+  const value = typeof process !== "undefined" ? process.env?.[name] : void 0;
+  return value || void 0;
+}
+function formatAmount(amount) {
+  if (typeof amount === "boolean") throw new TypeError("amount must be a number or string, not boolean");
+  if (typeof amount === "number" && !Number.isFinite(amount)) throw new TypeError(`Invalid amount: ${amount}`);
+  return String(amount);
+}
+function formatSize(size) {
+  return String(size);
+}
+function formatDate(value) {
+  return value instanceof Date ? value.toISOString().slice(0, 10) : value;
+}
+function formatDateTime(value) {
+  return value instanceof Date ? value.toISOString() : value;
+}
+function pathSegment(value) {
+  return encodeURIComponent(String(value));
+}
+function queryString(value) {
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (value instanceof Date) return formatDate(value);
+  return String(value);
+}
+function buildURL(baseURL, path, query) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) params.append(key, queryString(item));
+    } else {
+      params.append(key, queryString(value));
+    }
+  }
+  const qs = params.toString();
+  return `${baseURL}${path}${qs ? `?${qs}` : ""}`;
+}
+function cleanBody(body) {
+  const out = {};
+  for (const [key, value] of Object.entries(body)) {
+    if (value !== void 0 && value !== null) out[key] = value;
+  }
+  return out;
+}
+function joinStatuses(statuses) {
+  if (statuses === void 0 || statuses === null) return void 0;
+  return typeof statuses === "string" ? statuses : statuses.join(",");
+}
+function normalizeBatchDeleteItems(items) {
+  const out = [];
+  for (const item of items) {
+    if (typeof item === "string") {
+      out.push({ listingId: item });
+      continue;
+    }
+    let listingId;
+    let variantId;
+    if (Array.isArray(item)) {
+      [listingId, variantId] = item;
+    } else if (typeof item === "object" && item !== null) {
+      const obj = item;
+      listingId = obj.listingId ?? obj.listing_id;
+      variantId = obj.variantId ?? obj.variant_id;
+    } else {
+      throw new TypeError(`Unsupported batch-delete item: ${JSON.stringify(item)}`);
+    }
+    if (!listingId) throw new TypeError(`Batch-delete item is missing a listing ID: ${JSON.stringify(item)}`);
+    const entry = { listingId: String(listingId) };
+    if (variantId) entry.variantId = String(variantId);
+    out.push(entry);
+  }
+  if (out.length === 0) throw new TypeError("`items` is empty.");
+  return out;
+}
+var encoder = new TextEncoder();
+function isRowsSource(source) {
+  return typeof source === "object" && source !== null && !(source instanceof Uint8Array) && !(source instanceof ArrayBuffer) && !(typeof Blob !== "undefined" && source instanceof Blob) && "rows" in source;
+}
+function basename(path) {
+  return path.split(/[\\/]/).pop() || path;
+}
+async function collect(chunks) {
+  const parts = [];
+  let length = 0;
+  for await (const chunk of chunks) {
+    const bytes = typeof chunk === "string" ? encoder.encode(chunk) : new Uint8Array(chunk);
+    parts.push(bytes);
+    length += bytes.length;
+  }
+  const out = new Uint8Array(length);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+async function* readWebStream(stream) {
+  const reader = stream.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function prepareCsvUpload(source, defaultName) {
+  if (source === void 0 || source === null) {
+    throw new TypeError("Pass a CSV file (path, bytes, Blob or stream) or `{ rows }`.");
+  }
+  let name = defaultName;
+  let content;
+  if (typeof source === "string") {
+    const { readFile } = await import("fs/promises");
+    content = new Uint8Array(await readFile(source));
+    name = basename(source);
+  } else if (source instanceof Uint8Array) {
+    content = source;
+  } else if (source instanceof ArrayBuffer) {
+    content = new Uint8Array(source);
+  } else if (typeof Blob !== "undefined" && source instanceof Blob) {
+    content = new Uint8Array(await source.arrayBuffer());
+    const fileName = source.name;
+    if (typeof fileName === "string" && fileName) name = basename(fileName);
+  } else if (isRowsSource(source)) {
+    content = rowsToCsv(source.rows);
+  } else if (typeof source.getReader === "function") {
+    content = await collect(readWebStream(source));
+  } else if (typeof source[Symbol.asyncIterator] === "function") {
+    content = await collect(source);
+    const path = source.path;
+    if (typeof path === "string" && path) name = basename(path);
+  } else {
+    throw new TypeError(`Unsupported CSV source: ${Object.prototype.toString.call(source)}`);
+  }
+  if (!name.toLowerCase().endsWith(".csv")) name = `${name}.csv`;
+  return { name, content };
+}
+function csvField(value) {
+  if (value === void 0 || value === null) return "";
+  const text = value instanceof Date ? value.toISOString() : String(value);
+  return /[",\r\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function rowsToCsv(rows) {
+  const list = Array.from(rows);
+  if (list.length === 0) throw new TypeError("`rows` is empty.");
+  const header = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of list) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        header.push(key);
+      }
+    }
+  }
+  const lines = [header.map(csvField).join(",")];
+  for (const row of list) lines.push(header.map((key) => csvField(row[key])).join(","));
+  return encoder.encode(`${lines.join("\n")}
+`);
+}
+var CONNECT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "EADDRNOTAVAIL",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+function errorCodes(err, depth = 0) {
+  if (typeof err !== "object" || err === null || depth > 3) return [];
+  const e = err;
+  const codes = typeof e.code === "string" ? [e.code] : [];
+  if (Array.isArray(e.errors)) for (const inner of e.errors) codes.push(...errorCodes(inner, depth + 1));
+  codes.push(...errorCodes(e.cause, depth + 1));
+  return codes;
+}
+function classifyNetworkError(err) {
+  const codes = errorCodes(err);
+  if (codes.length > 0 && codes.every((code) => CONNECT_ERROR_CODES.has(code))) return "connect";
+  return "network";
+}
+function shouldRetryStatus(method, status) {
+  if (status === 429) return true;
+  if (status === 502 || status === 503 || status === 504) return IDEMPOTENT_METHODS.has(method.toUpperCase());
+  return false;
+}
+function shouldRetryNetworkError(method, kind) {
+  if (kind === "connect") return true;
+  return IDEMPOTENT_METHODS.has(method.toUpperCase());
+}
+function retryDelay(attempt, retryAfterSeconds) {
+  if (retryAfterSeconds !== null) return Math.min(retryAfterSeconds * 1e3, MAX_RETRY_AFTER_MS);
+  const base = Math.min(500 * 2 ** attempt, MAX_BACKOFF_MS);
+  return base * (0.75 + Math.random() * 0.5);
+}
+function jobFinished(payload) {
+  const status = typeof payload === "object" && payload !== null ? payload.status : void 0;
+  return typeof status === "string" && TERMINAL_JOB_STATUSES.has(status.toUpperCase());
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new APIUserAbortError({ cause: signal.reason }));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new APIUserAbortError({ cause: signal?.reason }));
+    };
+    const timer = setTimeout(
+      () => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      },
+      Math.max(0, ms)
+    );
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var timing = {
+  sleep: defaultSleep
+};
+
+// src/resources/shared.ts
+var APIResource = class {
+  _client;
+  constructor(client) {
+    this._client = client;
+  }
+  _conn(connectionId) {
+    return connectionId ?? this._client.connectionId;
+  }
+  _get(path, query, options) {
+    return this._client._request({ ...requestOptions(options), method: "GET", path, query });
+  }
+  _send(method, path, init = {}, options) {
+    const final = { ...requestOptions(options), method, path, ...init };
+    return this._client._request(final);
+  }
+  async _wait(fetchStatus, taskId, { pollInterval = 5e3, timeout = null, onProgress, signal } = {}) {
+    const deadline = timeout === null ? null : performance.now() + timeout;
+    for (; ; ) {
+      const status = await fetchStatus({ signal });
+      if (onProgress) await onProgress(status);
+      if (jobFinished(status)) return status;
+      if (deadline !== null && performance.now() + pollInterval > deadline) throw new JobTimeoutError(taskId, status);
+      await timing.sleep(pollInterval, signal);
+    }
+  }
+};
+function requestOptions(options) {
+  if (!options) return {};
+  const out = {};
+  if (options.timeout !== void 0) out.timeout = options.timeout;
+  if (options.maxRetries !== void 0) out.maxRetries = options.maxRetries;
+  if (options.signal !== void 0) out.signal = options.signal;
+  if (options.headers !== void 0) out.headers = options.headers;
+  return out;
+}
+
+// src/resources/goat.ts
+var GoatMarketResource = class extends APIResource {
+  /**
+   * `GET /v2/goat/market/search` — per-size GOAT prices. Needs a linked GOAT
+   * account (`ConflictError` otherwise).
+   */
+  search(styleId, options = {}) {
+    return this._get("/v2/goat/market/search", { style_id: styleId }, options);
+  }
+};
+var GoatResource = class extends APIResource {
+  market;
+  constructor(client) {
+    super(client);
+    this.market = new GoatMarketResource(client);
+  }
+};
+
+// src/resources/inventory.ts
+var InventoryResource = class extends APIResource {
+  /** `GET /v1/inventory/search` — one page of SKUs with stock per location. */
+  search(params = {}) {
+    return this._get(
+      "/v1/inventory/search",
+      {
+        q: params.q,
+        style_color: params.styleColor,
+        brand: params.brand,
+        retailer: params.retailer,
+        size: params.size === void 0 || params.size === null ? void 0 : formatSize(params.size),
+        retailer_sku: params.retailerSku,
+        supplier_sku: params.supplierSku,
+        limit: params.limit,
+        offset: params.offset
+      },
+      params
+    );
+  }
+  /**
+   * 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`.
+   */
+  async *iterSearch(params = {}) {
+    const { pageSize, offset: start, ...rest } = params;
+    let offset = start ?? 0;
+    for (; ; ) {
+      const page = await this.search({ ...rest, limit: pageSize, offset });
+      const items = page.items ?? [];
+      yield* items;
+      if (!page.has_next_page || items.length === 0) return;
+      offset += items.length;
+    }
+  }
+  /**
+   * `GET /v1/reporting/retailers/{retailer}/skus/{retailerSku}/history` —
+   * stock history of one SKU, newest first.
+   */
+  history(retailer, retailerSku, params = {}) {
+    return this._get(
+      `/v1/reporting/retailers/${pathSegment(retailer)}/skus/${pathSegment(retailerSku)}/history`,
+      { hours: params.hours },
+      params
+    );
+  }
+};
+
+// src/resources/stockx/catalog.ts
+var StockXCatalogResource = class extends APIResource {
+  /**
+   * `GET /v2/stockx/catalog/search` — StockX catalog search (usually by style
+   * code), returned as received from StockX.
+   */
+  search(q, params = {}) {
+    return this._get(
+      "/v2/stockx/catalog/search",
+      {
+        q,
+        page_number: params.pageNumber,
+        page_size: params.pageSize,
+        connection_id: this._conn(params.connectionId)
+      },
+      params
+    );
+  }
+  /**
+   * `GET /v2/stockx/catalog/products/{productId}/variants` — every size variant
+   * of a product, as received from StockX.
+   */
+  variants(productId, params = {}) {
+    return this._get(
+      `/v2/stockx/catalog/products/${pathSegment(productId)}/variants`,
+      { style_id: params.styleId, connection_id: this._conn(params.connectionId) },
+      params
+    );
+  }
+};
+
+// src/resources/stockx/costs.ts
+var StockXCostsResource = class extends APIResource {
+  /** `PATCH /v2/stockx/cost` — create or overwrite the cost for one style/size/variant. Basic plan. */
+  set(styleId, size, variantId, cost, params = {}) {
+    return this._send(
+      "PATCH",
+      "/v2/stockx/cost",
+      {
+        query: { connection_id: this._conn(params.connectionId) },
+        body: { styleId, size: formatSize(size), variantId, cost }
+      },
+      params
+    );
+  }
+  /** `GET /v2/stockx/costs` — cost records, newest first. */
+  list(params = {}) {
+    return this._get(
+      "/v2/stockx/costs",
+      {
+        page: params.page,
+        page_size: params.pageSize,
+        style_id: params.styleId,
+        connection_id: this._conn(params.connectionId)
+      },
+      params
+    );
+  }
+  /** Iterate every cost record across pages. */
+  async *iterList(params = {}) {
+    const { pageSize = 200, ...rest } = params;
+    let seen = 0;
+    for (let page = 1; ; page++) {
+      const data = await this.list({ ...rest, page, pageSize });
+      const items = data.items ?? [];
+      yield* items;
+      seen += items.length;
+      if (items.length === 0 || seen >= Number(data.total ?? 0)) return;
+    }
+  }
+  /**
+   * `POST /v2/stockx/costs/import` — upsert costs from a CSV with
+   * `style_id, size, variant_id, cost`. Synchronous. Advanced plan.
+   */
+  async importCsv(source, params = {}) {
+    const file = await prepareCsvUpload(source, "costs.csv");
+    return this._send(
+      "POST",
+      "/v2/stockx/costs/import",
+      { query: { connection_id: this._conn(params.connectionId) }, file },
+      params
+    );
+  }
+  /** `PATCH /v2/stockx/costs/{costId}` — edit one record. Basic plan. */
+  update(costId, params = {}) {
+    return this._send(
+      "PATCH",
+      `/v2/stockx/costs/${pathSegment(costId)}`,
+      {
+        query: { connection_id: this._conn(params.connectionId) },
+        body: cleanBody({ cost: params.cost, is_active: params.isActive })
+      },
+      params
+    );
+  }
+  /** `DELETE /v2/stockx/costs` — delete EVERY cost record on the connection. Cannot be undone. Basic plan. */
+  clear(params = {}) {
+    return this._send(
+      "DELETE",
+      "/v2/stockx/costs",
+      { query: { connection_id: this._conn(params.connectionId) } },
+      params
+    );
+  }
+};
+
+// src/resources/stockx/listings.ts
+var StockXListingsResource = class extends APIResource {
+  // -------------------------------------------------------------- single items
+  /**
+   * `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.
+   */
+  async createBySku(styleId, size, amount, params = {}) {
+    return this._send(
+      "POST",
+      "/v2/stockx/simple-listing",
+      {
+        query: { connection_id: this._conn(params.connectionId) },
+        body: cleanBody({
+          styleId,
+          size: formatSize(size),
+          amount: formatAmount(amount),
+          cost: params.cost,
+          currencyCode: params.currencyCode,
+          expiresAt: params.expiresAt == null ? void 0 : formatDateTime(params.expiresAt),
+          active: params.active,
+          inventoryType: params.inventoryType
+        })
+      },
+      params
+    );
+  }
+  /**
+   * `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.
+   */
+  async create(variantId, amount, params = {}) {
+    if (params.cost != null && (params.styleId == null || params.size == null)) {
+      throw new TypeError("`cost` is only stored together with `styleId` and `size`; pass all three.");
+    }
+    return this._send(
+      "POST",
+      "/v2/stockx/listings",
+      {
+        query: { connection_id: this._conn(params.connectionId) },
+        body: cleanBody({
+          variantId,
+          amount: formatAmount(amount),
+          currencyCode: params.currencyCode,
+          expiresAt: params.expiresAt == null ? void 0 : formatDateTime(params.expiresAt),
+          active: params.active,
+          inventoryType: params.inventoryType,
+          cost: params.cost,
+          styleId: params.styleId,
+          size: params.size == null ? void 0 : formatSize(params.size)
+        })
+      },
+      params
+    );
+  }
+  /** `PATCH /v2/stockx/listings/{listingId}` — reprice or change expiry. Requires the basic plan. */
+  async update(listingId, params = {}) {
+    return this._send(
+      "PATCH",
+      `/v2/stockx/listings/${pathSegment(listingId)}`,
+      {
+        query: { connection_id: this._conn(params.connectionId) },
+        body: cleanBody({
+          amount: params.amount == null ? void 0 : formatAmount(params.amount),
+          currencyCode: params.currencyCode,
+          expiresAt: params.expiresAt == null ? void 0 : formatDateTime(params.expiresAt)
+        })
+      },
+      params
+    );
+  }
+  /**
+   * `GET /v2/stockx/listings` — your listings, fetched live from StockX.
+   * ACTIVE listings carry `cost` and `netPrice`.
+   */
+  list(params = {}) {
+    return this._get(
+      "/v2/stockx/listings",
+      {
+        page_number: params.pageNumber,
+        page_size: params.pageSize,
+        listing_statuses: joinStatuses(params.listingStatuses),
+        sku: params.sku,
+        connection_id: this._conn(params.connectionId)
+      },
+      params
+    );
+  }
+  /** `GET /v2/stockx/listings/{listingId}` — one listing. */
+  get(listingId, params = {}) {
+    return this._get(
+      `/v2/stockx/listings/${pathSegment(listingId)}`,
+      { connection_id: this._conn(params.connectionId) },
+      params
+    );
+  }
+  /**
+   * `GET /v2/stockx/listings/{listingId}/operations/{operationId}` — result of
+   * an asynchronous StockX operation.
+   */
+  getOperation(listingId, operationId, params = {}) {
+    return this._get(
+      `/v2/stockx/listings/${pathSegment(listingId)}/operations/${pathSegment(operationId)}`,
+      { connection_id: this._conn(params.connectionId) },
+      params
+    );
+  }
+  /** `PUT /v2/stockx/listings/{listingId}/deactivate` — take off market, keep the listing. Basic plan. */
+  deactivate(listingId, params = {}) {
+    return this._send(
+      "PUT",
+      `/v2/stockx/listings/${pathSegment(listingId)}/deactivate`,
+      { query: { connection_id: this._conn(params.connectionId) } },
+      params
+    );
+  }
+  /**
+   * `PUT /v2/stockx/listings/{listingId}/activate` — put back on market,
+   * optionally at a new `amount`. Basic plan.
+   */
+  async activate(listingId, params = {}) {
+    return this._send(
+      "PUT",
+      `/v2/stockx/listings/${pathSegment(listingId)}/activate`,
+      {
+        query: { connection_id: this._conn(params.connectionId) },
+        body: params.amount == null ? void 0 : { amount: formatAmount(params.amount) }
+      },
+      params
+    );
+  }
+  /**
+   * `DELETE /v2/stockx/listings/{listingId}` — permanent. With `variantId` the
+   * variant's cost records are deleted too. Basic plan.
+   */
+  delete(listingId, params = {}) {
+    return this._send(
+      "DELETE",
+      `/v2/stockx/listings/${pathSegment(listingId)}`,
+      { query: { variant_id: params.variantId, connection_id: this._conn(params.connectionId) } },
+      params
+    );
+  }
+  /**
+   * `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`.
+   */
+  async batchDelete(items, params = {}) {
+    const normalized = normalizeBatchDeleteItems(items);
+    return this._send(
+      "POST",
+      "/v2/stockx/batch/delete-listing",
+      { query: { connection_id: this._conn(params.connectionId) }, body: { items: normalized } },
+      params
+    );
+  }
+  // -------------------------------------------------------------- CSV upload
+  /**
+   * `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.
+   */
+  async upload(source, params = {}) {
+    const file = await prepareCsvUpload(source, "listings.csv");
+    return this._send("POST", "/v2/stockx/listings/upload", { query: { batch_size: params.batchSize }, file }, params);
+  }
+  /**
+   * `POST /v2/stockx/listings/upload/validate` — count valid, invalid and
+   * duplicate rows without listing anything.
+   */
+  async validateUpload(source, options = {}) {
+    const file = await prepareCsvUpload(source, "listings.csv");
+    return this._send("POST", "/v2/stockx/listings/upload/validate", { file }, options);
+  }
+  /** `GET /v2/stockx/listings/upload/{taskId}` */
+  uploadStatus(taskId, options = {}) {
+    return this._get(`/v2/stockx/listings/upload/${pathSegment(taskId)}`, void 0, options);
+  }
+  /**
+   * Poll {@link uploadStatus} until the job is SUCCESS, FAILURE or CANCELLED,
+   * and return the final status. Throws `JobTimeoutError` after `timeout` ms.
+   */
+  waitForUpload(taskId, options = {}) {
+    return this._wait((o) => this.uploadStatus(taskId, o), taskId, options);
+  }
+  /** `GET /v2/stockx/listings/upload/unmatched` — uploaded rows that could not be matched to a variant. */
+  unmatched(options = {}) {
+    return this._get("/v2/stockx/listings/upload/unmatched", void 0, options);
+  }
+  // -------------------------------------------------------------- CSV unlist
+  /**
+   * `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.
+   */
+  async unlist(source, options = {}) {
+    const file = await prepareCsvUpload(source, "unlist.csv");
+    return this._send("POST", "/v2/stockx/listings/unlist", { file }, options);
+  }
+  /** `GET /v2/stockx/listings/unlist/{taskId}` */
+  unlistStatus(taskId, options = {}) {
+    return this._get(`/v2/stockx/listings/unlist/${pathSegment(taskId)}`, void 0, options);
+  }
+  /** Poll {@link unlistStatus} until the job finishes. */
+  waitForUnlist(taskId, options = {}) {
+    return this._wait((o) => this.unlistStatus(taskId, o), taskId, options);
+  }
+  /** `POST /v2/stockx/listings/unlist/cancel` — cancel your running unlist job. */
+  cancelUnlist(options = {}) {
+    return this._send("POST", "/v2/stockx/listings/unlist/cancel", {}, options);
+  }
+  // -------------------------------------------------------------- clear all
+  /**
+   * `POST /v2/stockx/listings/clear-all` — delete EVERY active listing in the
+   * account's `clear_all_scope`. Cannot be undone. Advanced plan.
+   */
+  clearAll(options = {}) {
+    return this._send("POST", "/v2/stockx/listings/clear-all", {}, options);
+  }
+  /** `GET /v2/stockx/listings/clear-all/{taskId}` */
+  clearAllStatus(taskId, options = {}) {
+    return this._get(`/v2/stockx/listings/clear-all/${pathSegment(taskId)}`, void 0, options);
+  }
+  /** Poll {@link clearAllStatus} until the job finishes. */
+  waitForClearAll(taskId, options = {}) {
+    return this._wait((o) => this.clearAllStatus(taskId, o), taskId, options);
+  }
+};
+
+// src/resources/stockx/market.ts
+var StockXMarketResource = class 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, params = {}) {
+    return this._get(
+      "/v2/stockx/market/search",
+      {
+        style_id: styleId,
+        size: params.size === void 0 || params.size === null ? void 0 : formatSize(params.size),
+        force: params.force
+      },
+      params
+    );
+  }
+  /** `GET /v2/stockx/market/hot` — style codes with recently cached quotes. */
+  hot(params = {}) {
+    return this._get("/v2/stockx/market/hot", { limit: params.limit, page: params.page }, params);
+  }
+  /** Iterate every recently quoted style code across pages. */
+  async *iterHot(params = {}) {
+    const { pageSize = 100, ...options } = params;
+    for (let page = 1; ; page++) {
+      const data = await this.hot({ ...options, limit: pageSize, page });
+      yield* data.items ?? [];
+      if (!data.has_next) return;
+    }
+  }
+  /**
+   * `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, variantId, params = {}) {
+    return this._get(
+      `/v2/stockx/catalog/products/${pathSegment(productId)}/variants/${pathSegment(variantId)}/market-data`,
+      { currency_code: params.currencyCode, connection_id: this._conn(params.connectionId) },
+      params
+    );
+  }
+};
+
+// src/resources/stockx/orders.ts
+var date = (value) => value == null ? void 0 : formatDate(value);
+var StockXOrdersResource = class extends APIResource {
+  /**
+   * `POST /v2/stockx/orders/sync` — start a background sync from StockX. There
+   * is no status endpoint; query again later.
+   */
+  sync(options = {}) {
+    return this._send("POST", "/v2/stockx/orders/sync", {}, options);
+  }
+  /** `GET /v2/stockx/orders` — synced orders, newest first. */
+  list(params = {}) {
+    return this._get(
+      "/v2/stockx/orders",
+      {
+        page: params.page,
+        page_size: params.pageSize,
+        order_status: params.orderStatus,
+        from_date: date(params.fromDate),
+        to_date: date(params.toDate),
+        search: params.search
+      },
+      params
+    );
+  }
+  /** Iterate every matching order across pages. */
+  async *iterList(params = {}) {
+    const { pageSize = 200, ...rest } = params;
+    let seen = 0;
+    for (let page = 1; ; page++) {
+      const data = await this.list({ ...rest, page, pageSize });
+      const orders = data.orders ?? [];
+      yield* orders;
+      seen += orders.length;
+      if (orders.length === 0 || seen >= Number(data.total ?? 0)) return;
+    }
+  }
+  /**
+   * `GET /v2/stockx/orders/analytics` — summary, top products/brands, sales
+   * trend and status breakdown.
+   */
+  analytics(params = {}) {
+    return this._get(
+      "/v2/stockx/orders/analytics",
+      { from_date: date(params.fromDate), to_date: date(params.toDate), granularity: params.granularity },
+      params
+    );
+  }
+};
+
+// src/resources/stockx/index.ts
+var StockXResource = class extends APIResource {
+  market;
+  catalog;
+  listings;
+  costs;
+  orders;
+  constructor(client) {
+    super(client);
+    this.market = new StockXMarketResource(client);
+    this.catalog = new StockXCatalogResource(client);
+    this.listings = new StockXListingsResource(client);
+    this.costs = new StockXCostsResource(client);
+    this.orders = new StockXOrdersResource(client);
+  }
+};
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/client.ts
+var MAX_TIMER_MS = 2 ** 31 - 1;
+var Client = class _Client {
+  baseURL;
+  timeout;
+  maxRetries;
+  connectionId;
+  inventory;
+  stockx;
+  goat;
+  #apiKey;
+  #customHeaders;
+  #fetch;
+  constructor(apiKeyOrOptions = {}, maybeOptions = {}) {
+    const options = typeof apiKeyOrOptions === "string" ? { ...maybeOptions, apiKey: apiKeyOrOptions } : apiKeyOrOptions;
+    const apiKey = options.apiKey || readEnv(API_KEY_ENV);
+    if (!apiKey) {
+      throw new SolometricsError(
+        `No API key provided. Pass { apiKey: '...' } or set the ${API_KEY_ENV} environment variable.`
+      );
+    }
+    this.#apiKey = apiKey;
+    this.baseURL = (options.baseURL || readEnv(BASE_URL_ENV) || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = options.timeout === void 0 ? DEFAULT_TIMEOUT : options.timeout;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.connectionId = options.connectionId ?? null;
+    this.#customHeaders = { ...options.defaultHeaders };
+    if (options.fetch) {
+      this.#fetch = options.fetch;
+    } else if (typeof globalThis.fetch === "function") {
+      this.#fetch = (url, init) => globalThis.fetch(url, init);
+    } else {
+      throw new SolometricsError("`fetch` is not available; use Node.js 18+ or pass { fetch } in the client options.");
+    }
+    this.inventory = new InventoryResource(this);
+    this.stockx = new StockXResource(this);
+    this.goat = new GoatResource(this);
+  }
+  get apiKey() {
+    return this.#apiKey;
+  }
+  /**
+   * 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) {
+    return new _Client({
+      apiKey: options.apiKey || this.#apiKey,
+      baseURL: this.baseURL,
+      timeout: options.timeout === void 0 ? this.timeout : options.timeout,
+      maxRetries: options.maxRetries ?? this.maxRetries,
+      connectionId: options.connectionId === void 0 ? this.connectionId : options.connectionId,
+      defaultHeaders: this.#customHeaders,
+      fetch: this.#fetch
+    });
+  }
+  // ------------------------------------------------------------------ low-level requests
+  /** Low-level GET for endpoints the SDK does not wrap yet. */
+  get(path, options = {}) {
+    return this._request({ ...options, method: "GET", path });
+  }
+  post(path, options = {}) {
+    return this._request({ ...options, method: "POST", path });
+  }
+  put(path, options = {}) {
+    return this._request({ ...options, method: "PUT", path });
+  }
+  patch(path, options = {}) {
+    return this._request({ ...options, method: "PATCH", path });
+  }
+  delete(path, options = {}) {
+    return this._request({ ...options, method: "DELETE", path });
+  }
+  /** @internal */
+  async _request(options) {
+    const maxRetries = options.maxRetries ?? this.maxRetries;
+    const timeout = options.timeout === void 0 ? this.timeout : options.timeout;
+    const url = buildURL(this.baseURL, options.path, options.query);
+    const userSignal = options.signal ?? void 0;
+    for (let attempt = 0; ; attempt++) {
+      if (userSignal?.aborted) throw new APIUserAbortError({ cause: userSignal.reason });
+      const controller = new AbortController();
+      let timedOut = false;
+      const timer = timeout !== null && Number.isFinite(timeout) ? setTimeout(
+        () => {
+          timedOut = true;
+          controller.abort();
+        },
+        Math.min(Math.max(timeout, 0), MAX_TIMER_MS)
+      ) : void 0;
+      const onUserAbort = () => controller.abort(userSignal?.reason);
+      userSignal?.addEventListener("abort", onUserAbort, { once: true });
+      let response;
+      let text;
+      try {
+        response = await this.#fetch(url, {
+          method: options.method,
+          headers: this.#headers(options),
+          body: this.#body(options),
+          signal: controller.signal
+        });
+        text = await response.text();
+      } catch (err) {
+        if (userSignal?.aborted) throw new APIUserAbortError({ cause: err });
+        const kind = timedOut ? "timeout" : classifyNetworkError(err);
+        if (attempt < maxRetries && shouldRetryNetworkError(options.method, kind)) {
+          await timing.sleep(retryDelay(attempt, null), userSignal);
+          continue;
+        }
+        if (kind === "timeout") throw new APITimeoutError({ cause: err });
+        throw new APIConnectionError(connectionErrorMessage(err), { cause: err });
+      } finally {
+        clearTimeout(timer);
+        userSignal?.removeEventListener("abort", onUserAbort);
+      }
+      if (response.ok) return parseBody(response.status, text);
+      if (attempt < maxRetries && shouldRetryStatus(options.method, response.status)) {
+        const retryAfter = parseRetryAfter(response.headers);
+        await timing.sleep(retryDelay(attempt, retryAfter), userSignal);
+        continue;
+      }
+      throw makeStatusError(response.status, response.statusText, response.headers, text);
+    }
+  }
+  #headers(options) {
+    const headers = {
+      "X-API-Key": this.#apiKey,
+      Accept: "application/json",
+      "User-Agent": `solometrics-node/${VERSION}`
+    };
+    if (options.body !== void 0 && !options.file) headers["Content-Type"] = "application/json";
+    return { ...headers, ...this.#customHeaders, ...options.headers };
+  }
+  /** Built per attempt, so a multipart body can be resent on retry. */
+  #body(options) {
+    if (options.file) {
+      const form = new FormData();
+      form.append(
+        "file",
+        new Blob([options.file.content], { type: "text/csv" }),
+        options.file.name
+      );
+      return form;
+    }
+    return options.body === void 0 ? void 0 : JSON.stringify(options.body);
+  }
+  toString() {
+    return `Client { baseURL: '${this.baseURL}' }`;
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+};
+function parseBody(status, text) {
+  if (status === 204 || text === "") return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function connectionErrorMessage(err) {
+  if (err instanceof Error) {
+    const cause = err.cause instanceof Error ? `: ${err.cause.message}` : "";
+    return `${err.message}${cause}` || "Connection error.";
+  }
+  return "Connection error.";
+}
+//# sourceMappingURL=index.cjs.map