@omni-commerce/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2709 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/BaseClient.ts
+function normalizeClientOptions(options = {}) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error(
+      "No fetch implementation found. Pass `fetch` in OmniClient options."
+    );
+  }
+  return {
+    environment: options.environment,
+    baseUrl: options.baseUrl,
+    apiKey: options.apiKey,
+    headers: options.headers,
+    timeoutInSeconds: options.timeoutInSeconds ?? 60,
+    maxRetries: options.maxRetries ?? 2,
+    fetch: fetchImpl
+  };
+}
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+var SDK_USER_AGENT = `omnicommerce-js/${SDK_VERSION}`;
+
+// src/environments.ts
+var OmniEnvironment = {
+  Production: "https://omnicommerce.sg",
+  Local: "http://localhost:3000"
+};
+
+// src/errors/OmniError.ts
+var OmniError = class extends Error {
+  statusCode;
+  body;
+  rawResponse;
+  constructor({
+    message,
+    statusCode,
+    body,
+    rawResponse
+  }) {
+    super(message ?? defaultErrorMessage(statusCode, body));
+    this.name = "OmniError";
+    this.statusCode = statusCode;
+    this.body = body;
+    this.rawResponse = rawResponse;
+  }
+};
+function defaultErrorMessage(statusCode, body) {
+  const fromBody = extractErrorMessage(body);
+  if (fromBody) return fromBody;
+  if (statusCode) return `Omni API error (${statusCode})`;
+  return "Omni API error";
+}
+function extractErrorMessage(body) {
+  if (typeof body === "string" && body.trim()) return body;
+  if (!body || typeof body !== "object") return void 0;
+  const record = body;
+  for (const key of ["error", "message", "detail"]) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return void 0;
+}
+
+// src/errors/OmniTimeoutError.ts
+var OmniTimeoutError = class extends Error {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "OmniTimeoutError";
+  }
+};
+
+// src/errors/status.ts
+var BadRequestError = class extends OmniError {
+  constructor(body, rawResponse) {
+    super({ message: "Bad request", statusCode: 400, body, rawResponse });
+    this.name = "BadRequestError";
+  }
+};
+var UnauthorizedError = class extends OmniError {
+  constructor(body, rawResponse) {
+    super({ message: "Unauthorized", statusCode: 401, body, rawResponse });
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends OmniError {
+  constructor(body, rawResponse) {
+    super({ message: "Forbidden", statusCode: 403, body, rawResponse });
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends OmniError {
+  constructor(body, rawResponse) {
+    super({ message: "Not found", statusCode: 404, body, rawResponse });
+    this.name = "NotFoundError";
+  }
+};
+var UnprocessableEntityError = class extends OmniError {
+  constructor(body, rawResponse) {
+    super({
+      message: "Unprocessable entity",
+      statusCode: 422,
+      body,
+      rawResponse
+    });
+    this.name = "UnprocessableEntityError";
+  }
+};
+var TooManyRequestsError = class extends OmniError {
+  constructor(body, rawResponse) {
+    super({
+      message: "Too many requests",
+      statusCode: 429,
+      body,
+      rawResponse
+    });
+    this.name = "TooManyRequestsError";
+  }
+};
+var InternalServerError = class extends OmniError {
+  constructor(body, rawResponse) {
+    super({
+      message: "Internal server error",
+      statusCode: 500,
+      body,
+      rawResponse
+    });
+    this.name = "InternalServerError";
+  }
+};
+var BadGatewayError = class extends OmniError {
+  constructor(body, rawResponse) {
+    super({ message: "Bad gateway", statusCode: 502, body, rawResponse });
+    this.name = "BadGatewayError";
+  }
+};
+var ServiceUnavailableError = class extends OmniError {
+  constructor(body, rawResponse) {
+    super({
+      message: "Service unavailable",
+      statusCode: 503,
+      body,
+      rawResponse
+    });
+    this.name = "ServiceUnavailableError";
+  }
+};
+function errorFromStatus(statusCode, body, rawResponse) {
+  switch (statusCode) {
+    case 400:
+      return new BadRequestError(body, rawResponse);
+    case 401:
+      return new UnauthorizedError(body, rawResponse);
+    case 403:
+      return new ForbiddenError(body, rawResponse);
+    case 404:
+      return new NotFoundError(body, rawResponse);
+    case 422:
+      return new UnprocessableEntityError(body, rawResponse);
+    case 429:
+      return new TooManyRequestsError(body, rawResponse);
+    case 500:
+      return new InternalServerError(body, rawResponse);
+    case 502:
+      return new BadGatewayError(body, rawResponse);
+    case 503:
+      return new ServiceUnavailableError(body, rawResponse);
+    default:
+      return new OmniError({ statusCode, body, rawResponse });
+  }
+}
+
+// src/core/supplier.ts
+async function getSupplierValue(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "function") {
+    return await value();
+  }
+  return value;
+}
+
+// src/core/query.ts
+var isPlainObject = (value) => Boolean(value) && Object.getPrototypeOf(value) === Object.prototype;
+function toQueryString(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    appendQueryParam(params, key, value);
+  }
+  return params.toString();
+}
+function appendQueryParam(params, key, value) {
+  if (value === void 0 || value === null) return;
+  if (Array.isArray(value)) {
+    for (const item of value) appendQueryParam(params, key, item);
+    return;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    params.append(key, String(value));
+    return;
+  }
+  if (typeof value === "string") {
+    params.append(key, value);
+    return;
+  }
+  if (isPlainObject(value) || Array.isArray(value)) {
+    params.append(key, JSON.stringify(value));
+    return;
+  }
+  params.append(key, String(value));
+}
+function joinUrl(baseUrl, path, query) {
+  const trimmedBase = baseUrl.replace(/\/+$/, "");
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const url = `${trimmedBase}${normalizedPath}`;
+  return query ? `${url}?${query}` : url;
+}
+
+// src/core/http-response-promise.ts
+var HttpResponsePromise = class _HttpResponsePromise extends Promise {
+  #response;
+  constructor(executor, response) {
+    super(executor);
+    this.#response = response;
+  }
+  static from(response) {
+    return new _HttpResponsePromise((resolve, reject) => {
+      void response.then((result) => resolve(result.data), reject);
+    }, response);
+  }
+  withRawResponse() {
+    return this.#response;
+  }
+};
+function toRawResponse(response) {
+  return {
+    status: response.status,
+    headers: response.headers,
+    url: response.url
+  };
+}
+
+// src/core/fetcher.ts
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS", "PUT", "DELETE"]);
+var OmniHttp = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  request(init) {
+    return HttpResponsePromise.from(this.requestWithRaw(init));
+  }
+  async requestWithRaw(init) {
+    const url = await this.buildUrl(init);
+    const headers = await this.buildHeaders(init);
+    const serialized = serializeBody(init.body, headers);
+    const timeoutMs = (init.timeoutInSeconds ?? this.options.timeoutInSeconds) * 1e3;
+    const maxRetries = init.maxRetries ?? this.options.maxRetries;
+    const fetchImpl = this.options.fetch;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), timeoutMs);
+      const onAbort = () => controller.abort();
+      init.abortSignal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        const response = await fetchImpl(url, {
+          method: init.method,
+          headers,
+          body: serialized.body,
+          signal: controller.signal
+        });
+        const rawResponse = toRawResponse(response);
+        if (response.ok) {
+          const data = await parseSuccessBody(response);
+          return { data, rawResponse };
+        }
+        const errorBody = await parseErrorBody(response);
+        if (attempt < maxRetries && shouldRetry(init.method, response.status)) {
+          await sleep(
+            retryDelayMs(attempt, response.headers.get("retry-after"))
+          );
+          continue;
+        }
+        throw errorFromStatus(response.status, errorBody, rawResponse);
+      } catch (error) {
+        lastError = error;
+        if (error instanceof OmniError) throw error;
+        const aborted = error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+        if (aborted && init.abortSignal?.aborted) {
+          throw error;
+        }
+        if (aborted) {
+          lastError = new OmniTimeoutError(
+            `Request timed out after ${timeoutMs}ms`
+          );
+        }
+        if (attempt >= maxRetries || !shouldRetry(init.method, void 0)) {
+          throw lastError;
+        }
+        await sleep(retryDelayMs(attempt, null));
+      } finally {
+        clearTimeout(timeout);
+        init.abortSignal?.removeEventListener("abort", onAbort);
+      }
+    }
+    throw lastError;
+  }
+  async buildUrl(init) {
+    const baseUrl = await getSupplierValue(this.options.baseUrl) ?? await getSupplierValue(this.options.environment) ?? OmniEnvironment.Production;
+    const query = toQueryString({
+      ...init.query,
+      ...init.queryParams
+    });
+    return joinUrl(baseUrl, init.path, query);
+  }
+  async buildHeaders(init) {
+    const headers = {
+      Accept: "application/json",
+      "User-Agent": SDK_USER_AGENT
+    };
+    const apiKey = await getSupplierValue(this.options.apiKey) ?? readEnvApiKey();
+    if (apiKey) {
+      headers.Authorization = `Bearer ${apiKey}`;
+    }
+    if (this.options.headers) {
+      for (const [key, value] of Object.entries(this.options.headers)) {
+        const resolved = await getSupplierValue(value ?? void 0);
+        if (resolved) headers[key] = resolved;
+      }
+    }
+    if (init.headers) {
+      for (const [key, value] of Object.entries(init.headers)) {
+        if (value) headers[key] = value;
+      }
+    }
+    return headers;
+  }
+};
+function mergeRequestOptions(requestOptions) {
+  return {
+    timeoutInSeconds: requestOptions?.timeoutInSeconds,
+    maxRetries: requestOptions?.maxRetries,
+    abortSignal: requestOptions?.abortSignal,
+    queryParams: requestOptions?.queryParams,
+    headers: requestOptions?.headers
+  };
+}
+function readEnvApiKey() {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  const value = process.env.OMNI_API_KEY;
+  return value && value.trim() ? value : void 0;
+}
+function serializeBody(body, headers) {
+  if (body === void 0 || body === null) return {};
+  if (typeof FormData !== "undefined" && body instanceof FormData) {
+    return { body };
+  }
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) {
+    if (!headers["Content-Type"]) {
+      headers["Content-Type"] = "application/x-www-form-urlencoded";
+    }
+    return { body };
+  }
+  if (typeof Blob !== "undefined" && body instanceof Blob) {
+    return { body };
+  }
+  if (typeof body === "string") {
+    if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
+    return { body };
+  }
+  if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
+  return { body: JSON.stringify(body) };
+}
+async function parseSuccessBody(response) {
+  if (response.status === 204) return void 0;
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    const text2 = await response.text();
+    if (!text2) return void 0;
+    return JSON.parse(text2);
+  }
+  if (contentType.includes("text/")) {
+    return response.text();
+  }
+  const text = await response.text();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+async function parseErrorBody(response) {
+  const text = await response.text();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function shouldRetry(method, status) {
+  if (status === 408 || status === 429) return true;
+  const idempotent = IDEMPOTENT_METHODS.has(method.toUpperCase());
+  if (status !== void 0) {
+    return idempotent && status >= 500;
+  }
+  return idempotent;
+}
+function retryDelayMs(attempt, retryAfter) {
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return Math.min(seconds * 1e3, 3e4);
+    }
+  }
+  const base = Math.min(500 * 2 ** attempt, 8e3);
+  return base + Math.random() * base * 0.2;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/path.ts
+function encodePathParam(name, value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`Missing required path parameter: ${name}`);
+  }
+  return encodeURIComponent(value);
+}
+
+// src/jobs.ts
+var SUCCESS_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "complete",
+  "succeeded",
+  "success"
+]);
+var FAILURE_STATUSES = /* @__PURE__ */ new Set(["failed", "error"]);
+var CANCELLED_STATUSES = /* @__PURE__ */ new Set(["cancelled", "canceled"]);
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  ...SUCCESS_STATUSES,
+  ...FAILURE_STATUSES,
+  ...CANCELLED_STATUSES
+]);
+var JobFailedError = class extends OmniError {
+  jobStatus;
+  constructor(jobStatus, body) {
+    super({
+      message: `Job ended with status "${jobStatus}"`,
+      body
+    });
+    this.name = "JobFailedError";
+    this.jobStatus = jobStatus;
+  }
+};
+function readJobStatus(payload) {
+  if (!payload || typeof payload !== "object") return void 0;
+  const record = payload;
+  const nested = record.data;
+  if (nested && typeof nested === "object") {
+    const nestedStatus = nested.status;
+    if (typeof nestedStatus === "string" && nestedStatus.trim()) {
+      return nestedStatus;
+    }
+  }
+  if (typeof record.status === "string" && record.status.trim()) {
+    return record.status;
+  }
+  return void 0;
+}
+async function waitForJob(http, request, options) {
+  const intervalMs = options?.intervalMs ?? 2e3;
+  const timeoutMs = (options?.timeoutInSeconds ?? 300) * 1e3;
+  const started = Date.now();
+  while (true) {
+    const result = await http.requestWithRaw({
+      method: "GET",
+      path: `/api/v1/jobs/${encodeURIComponent(request.jobId)}`,
+      query: request.organizationId ? { organizationId: request.organizationId } : void 0,
+      timeoutInSeconds: options?.timeoutInSeconds,
+      maxRetries: options?.maxRetries,
+      abortSignal: options?.abortSignal,
+      queryParams: options?.queryParams,
+      headers: options?.headers
+    });
+    const status = readJobStatus(result.data)?.toLowerCase();
+    if (status && TERMINAL_STATUSES.has(status)) {
+      if (SUCCESS_STATUSES.has(status)) return result.data;
+      throw new JobFailedError(status, result.data);
+    }
+    if (Date.now() - started + intervalMs > timeoutMs) {
+      throw new OmniError({
+        message: `Timed out waiting for job ${request.jobId}`,
+        body: result.data
+      });
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}
+
+// src/generated/resources.ts
+var AopClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Get AOP configuration
+   *
+   * Retrieve prompt, agent, structured inputs/output, and notification settings. Requires `aops:read`.
+   *
+   * `GET /api/v1/aop/{aopId}/config`
+   */
+  getConfig(request, requestOptions) {
+    const { aopId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/aop/${encodePathParam("aopId", aopId)}/config`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Overwrite AOP configuration
+   *
+   * Updates AOP configuration. Omitted fields keep their current values. Send `user_notification_configs: null` to clear notification overrides. Requires `aops:write`.
+   *
+   * `PUT /api/v1/aop/{aopId}/config`
+   */
+  updateConfig(request, requestOptions) {
+    const { aopId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PUT",
+      path: `/api/v1/aop/${encodePathParam("aopId", aopId)}/config`,
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Execute an AOP
+   *
+   * Start an AOP run and return immediately with a `thread_id`. Poll `GET /api/v1/threads/{thread_id}/status`. Requires `aops:write`.
+   *
+   * `POST /api/v1/aop/{aopId}/execute`
+   */
+  execute(request, requestOptions) {
+    const { aopId, ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: `/api/v1/aop/${encodePathParam("aopId", aopId)}/execute`,
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Create AOP
+   *
+   * Create an organization-scoped AOP. Use `[[ placeholder ]]` in the prompt for user inputs supplied at execution time. Requires `aops:write`.
+   *
+   * `POST /api/v1/aop/create`
+   */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/aop/create",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Retry a failed AOP execution
+   *
+   * Looks up a failed AOP thread, then enqueues a new run. Requires `aops:write`.
+   *
+   * `POST /api/v1/aop/retry`
+   */
+  retry(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/aop/retry",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var ApiClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * API Root
+   *
+   * Public API discovery root. Merchant payments are handled by organization-scoped checkout session endpoints.
+   *
+   * `GET /api`
+   */
+  root(requestOptions) {
+    return this._http.request({
+      method: "GET",
+      path: "/api",
+      query: void 0,
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * API v1 Root
+   *
+   * Public API v1 discovery root. Merchant payments are handled by organization-scoped checkout session endpoints.
+   *
+   * `GET /api/v1`
+   */
+  v1(requestOptions) {
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1",
+      query: void 0,
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var CatalogClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+     * Export Catalog Items
+     *
+     * Cursor-page the authenticated organization's product and variant catalog for pricing systems. Requires `catalog:read`.
+  
+  Each item includes product-family identity, SKU/UPC, cost, current, sale, compare-at, MAP, and MSRP prices, inventory, active promotion context, and exact marketplace identifiers. Set `format=csv` for a flat catalog-intake CSV shape.
+     *
+     * `GET /api/v1/catalog/items`
+     */
+  listItems(request = {}, requestOptions) {
+    const { organizationId, updatedSince, cursor, limit, format } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/catalog/items",
+      query: { organizationId, updatedSince, cursor, limit, format },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var CheckoutSessionsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Create Agentic Checkout Session
+   *
+   * Create a merchant-fulfilled checkout session, reserve inventory, and return rail-specific payment requirements. Requires an OAuth client token with `checkout:write`.
+   *
+   * `POST /api/v1/checkout-sessions`
+   */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/checkout-sessions",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Get Agentic Checkout Session
+   *
+   * Fetch the current checkout session, cart items, totals, payment requirements, and linked order when completed.
+   *
+   * `GET /api/v1/checkout-sessions/{sessionId}`
+   */
+  get(request, requestOptions) {
+    const { sessionId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/checkout-sessions/${encodePathParam("sessionId", sessionId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Update Agentic Checkout Session
+   *
+   * Update cart/contact fields, recompute totals, and refresh inventory reservations before payment. Requires `checkout:write`.
+   *
+   * `PATCH /api/v1/checkout-sessions/{sessionId}`
+   */
+  update(request, requestOptions) {
+    const { sessionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PATCH",
+      path: `/api/v1/checkout-sessions/${encodePathParam("sessionId", sessionId)}`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Replace Agentic Checkout Session Fields
+   *
+   * UCP-compatible update method for cart/contact fields. The current implementation applies provided fields and leaves omitted fields unchanged. Requires `checkout:write`.
+   *
+   * `PUT /api/v1/checkout-sessions/{sessionId}`
+   */
+  replace(request, requestOptions) {
+    const { sessionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PUT",
+      path: `/api/v1/checkout-sessions/${encodePathParam("sessionId", sessionId)}`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Cancel Agentic Checkout Session
+   *
+   * Cancel a ready-for-payment checkout session and release reserved inventory. This operation is exposed for UCP REST clients and requires `checkout:write`.
+   *
+   * `POST /api/v1/checkout-sessions/{sessionId}/cancel`
+   */
+  cancel(request, requestOptions) {
+    const { sessionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: `/api/v1/checkout-sessions/${encodePathParam("sessionId", sessionId)}/cancel`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Complete Agentic Checkout Session
+   *
+   * Settle the selected rail and create a native `agentic` order. Settlement failures return 402 and leave the session in `ready_for_payment`.
+   *
+   * `POST /api/v1/checkout-sessions/{sessionId}/complete`
+   */
+  complete(request, requestOptions) {
+    const { sessionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: `/api/v1/checkout-sessions/${encodePathParam("sessionId", sessionId)}/complete`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var CompareClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Compare Public Products
+   *
+   * Compare 2 to 10 public products side-by-side across price, ACO readiness, marketplace coverage, and inventory.
+   *
+   * `GET /api/v1/compare`
+   */
+  get(request, requestOptions) {
+    const { products, language } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/compare",
+      query: { products, language },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var DirectoryClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Public Merchants
+   *
+   * Discover merchants with public products available through OmniCommerce's public agent APIs.
+   *
+   * `GET /api/v1/directory`
+   */
+  list(requestOptions) {
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/directory",
+      query: void 0,
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var EvaluateClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Evaluate SKU Readiness
+   *
+   * Score a persisted product or inline SKU payload for agentic commerce readiness, engine eligibility, and recommended fixes.
+   *
+   * `POST /api/v1/evaluate`
+   */
+  run(request = {}, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/evaluate",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var FeedClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Get Merchant LLM Feed
+   *
+   * Return a plain-text, LLM-optimized merchant feed keyed by website domain.
+   *
+   * `GET /api/v1/feed/{domain}/llms.txt`
+   */
+  getLlmsTxt(request, requestOptions) {
+    const { domain, limit } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/feed/${encodePathParam("domain", domain)}/llms.txt`,
+      query: { limit },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var ImagesClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Generate Ghost Mannequin Image
+   *
+   * Remove the visible mannequin from a product photo and return the generated image URL. The source image must be an HTTP(S) URL; data URIs are rejected. Authenticate with an OmniCommerce API key that has the `catalog:enrich` scope.
+   *
+   * `POST /api/v1/images/ghost-mannequin`
+   */
+  ghostMannequin(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/images/ghost-mannequin",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var JobsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Get Developer Job Status
+   *
+   * Fetch shared async status for developer-platform operations, including product workflow jobs, bulk CSV import jobs, Look generation jobs, import jobs, enrichment jobs, and sync jobs.
+   *
+   * `GET /api/v1/jobs/{jobId}`
+   */
+  get(request, requestOptions) {
+    const { jobId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/jobs/${encodePathParam("jobId", jobId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Cancel Developer Job
+     *
+     * Request cancellation for a running or pending developer job.
+  
+  Supported jobs:
+  
+  - Product workflows returned by `POST /api/v1/products`
+  
+  - Bulk CSV imports returned by `POST /api/v1/products/bulk-import`
+  
+  - Look generation returned by `POST /api/v1/looks`
+  
+  Completed or failed jobs cannot be cancelled and are returned with their current terminal status.
+     *
+     * `POST /api/v1/jobs/{jobId}/cancel`
+     */
+  cancel(request, requestOptions) {
+    const { jobId, ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: `/api/v1/jobs/${encodePathParam("jobId", jobId)}/cancel`,
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Poll `GET /api/v1/jobs/{jobId}` until the nested job status is terminal.
+   */
+  wait(request, requestOptions) {
+    return waitForJob(this._http, request, requestOptions);
+  }
+};
+var LooksClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Looks
+   *
+   * List AI-styled product Looks for the authenticated organization, newest first. Use query parameters for search, status filtering, and pagination.
+   *
+   * `GET /api/v1/looks`
+   */
+  list(request = {}, requestOptions) {
+    const { q, status, limit, offset } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/looks",
+      query: { q, status, limit, offset },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Create Look
+   *
+   * Create a Look from existing catalog products and queue AI image generation for a fast preview. The response is asynchronous: poll `GET /api/v1/jobs/{jobId}?organizationId={organizationId}` until the `look_...` job completes, then fetch the generated Look with `GET /api/v1/looks/{lookId}`.
+   *
+   * `POST /api/v1/looks`
+   */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/looks",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Get Look
+   *
+   * Fetch a single Look by ID, including the generated hero image URL and the shoppable product cards used in the Look.
+   *
+   * `GET /api/v1/looks/{lookId}`
+   */
+  get(request, requestOptions) {
+    const { lookId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/looks/${encodePathParam("lookId", lookId)}`,
+      query: void 0,
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var MarketplacesClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Connected Marketplaces
+   *
+   * List connected marketplace stores for the authenticated organization. Results are scoped to the API key organization unless `organizationId` is supplied for session-authenticated calls.
+   *
+   * `GET /api/v1/marketplaces/connected`
+   */
+  listConnected(request = {}, requestOptions) {
+    const { organizationId, marketplace, country } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/marketplaces/connected",
+      query: { organizationId, marketplace, country },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var MerchantsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Get Public Merchant Manifest
+   *
+   * Return machine-readable capability and endpoint metadata for a single public merchant.
+   *
+   * `GET /api/v1/merchants/{merchantId}/manifest`
+   */
+  getManifest(request, requestOptions) {
+    const { merchantId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/merchants/${encodePathParam("merchantId", merchantId)}/manifest`,
+      query: void 0,
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * List Public Merchant Products
+   *
+   * Browse a single merchant's public product feed with optional marketplace and localization filters.
+   *
+   * `GET /api/v1/merchants/{merchantId}/products`
+   */
+  listProducts(request, requestOptions) {
+    const { merchantId, platform, country, language, limit, offset } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/merchants/${encodePathParam("merchantId", merchantId)}/products`,
+      query: { platform, country, language, limit, offset },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Search Within Public Merchant Catalog
+   *
+   * Search within a single merchant's public product feed using the same filter model as the cross-merchant search API.
+   *
+   * `GET /api/v1/merchants/{merchantId}/search`
+   */
+  search(request, requestOptions) {
+    const {
+      merchantId,
+      q,
+      category,
+      brand,
+      min_price,
+      max_price,
+      in_stock,
+      sort,
+      platform,
+      country,
+      language,
+      include_intent,
+      limit,
+      offset
+    } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/merchants/${encodePathParam("merchantId", merchantId)}/search`,
+      query: {
+        q,
+        category,
+        brand,
+        min_price,
+        max_price,
+        in_stock,
+        sort,
+        platform,
+        country,
+        language,
+        include_intent,
+        limit,
+        offset
+      },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var MonitorClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Run AI Shelf Share Monitor
+   *
+   * Queue AI Shelf Share replay/monitoring for a product, query, or organization catalog.
+   *
+   * `POST /api/v1/monitor`
+   */
+  run(request = {}, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/monitor",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var OauthClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Revoke Access Token
+   *
+   * Revoke an OAuth bearer access token using client_secret_post authentication.
+   *
+   * `POST /api/v1/oauth/revoke`
+   */
+  revoke(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/oauth/revoke",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Get Access Token
+   *
+   * Exchange client credentials for an access token using OAuth 2.0 client_credentials grant. Tokens are valid for 1 hour.
+   *
+   * `POST /api/v1/oauth/token`
+   */
+  token(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/oauth/token",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var OrdersClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Orders
+   *
+   * List orders for the authenticated organization using the same filters, sorting, and pagination semantics as the workspace Orders listing page. Requires `orders:read`.
+   *
+   * `GET /api/v1/orders`
+   */
+  list(request = {}, requestOptions) {
+    const {
+      organizationId,
+      q,
+      status,
+      marketplace,
+      country,
+      store,
+      bundleType,
+      sortBy,
+      dateFrom,
+      dateTo,
+      limit,
+      offset
+    } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/orders",
+      query: {
+        organizationId,
+        q,
+        status,
+        marketplace,
+        country,
+        store,
+        bundleType,
+        sortBy,
+        dateFrom,
+        dateTo,
+        limit,
+        offset
+      },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Create Order
+     *
+     * Create a native `agentic` order with line items. This operation uses the same upsert path as agentic checkout completion.
+  
+  ### Authentication
+  
+  Requires `orders:write`.
+  
+  ### Upsert behavior
+  
+  - Reusing an `externalOrderId` updates the existing order instead of creating a duplicate.
+  - For one-row-per-SKU integrations, use the marketplace order ID as `externalOrderId` and the row ID as `items[].externalOrderItemId`.
+  - When `totalAmount` is omitted, OmniCommerce recomputes it from all order lines after the upsert.
+  
+  ### Pricing and catalog defaults
+  
+  - Each line can provide `price`, `unitPrice`, `paidPrice`, and `costPrice`.
+  - When `productId` is provided, missing price or currency values may resolve from the product catalog.
+  - An explicit `costPrice` updates `product_data.costPrice` and is snaps
+     *
+     * `POST /api/v1/orders`
+     */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/orders",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Get Order
+     *
+     * Get one order by its OmniCommerce UUID for the authenticated organization.
+  
+  ### Authentication
+  
+  Requires `orders:read`.
+  
+  ### Response
+  
+  The organization-scoped detail includes:
+  
+  - Line items and normalized status
+  - Buyer and contact fields
+  - Shipping and billing addresses
+  - Return context
+  - Finance breakdown
+  - Settlement projection, when available
+  
+  Orders outside the authenticated organization are not exposed and return `404 Not Found`.
+     *
+     * `GET /api/v1/orders/{orderId}`
+     */
+  get(request, requestOptions) {
+    const { orderId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/orders/${encodePathParam("orderId", orderId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Update Order
+     *
+     * Update a native **agentic** order.
+  
+  ### Authentication
+  
+  Requires `orders:write`.
+  
+  ### Supported changes
+  
+  - External order identifiers, status, currency, and country
+  - `totalAmount`, `shippingFee`, and `discountAmount`
+  - Metadata and `orderCreatedAt`
+  - Line identifiers, prices, COGS, currency, status, and quantity
+  
+  ### Line upserts
+  
+  - A matching `externalOrderItemId` updates the existing line.
+  - A new `externalOrderItemId` with `productName` and `quantity` appends a line.
+  - When lines change and `totalAmount` is omitted, OmniCommerce recomputes the total from all lines.
+  
+  ### Country resolution
+  
+  When `country` is omitted and the stored country is empty, OmniCommerce may derive it from an unambiguous resulting order currency.
+  
+  ### Restrictions and events
+  
+  Marketplace-owned orders from Shopee,
+     *
+     * `PATCH /api/v1/orders/{orderId}`
+     */
+  update(request, requestOptions) {
+    const { orderId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PATCH",
+      path: `/api/v1/orders/${encodePathParam("orderId", orderId)}`,
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var OrganizationsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Create Organization
+   *
+   * Create a new organization for the signed-in user. This endpoint uses first-party session authentication because API keys are scoped to an existing organization.
+   *
+   * `POST /api/v1/organizations`
+   */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/organizations",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var PriceBooksClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Price Book Rules
+   *
+   * List marketplace price book rules for the authenticated organization. A rule applies either a buyer formula or a markup percent to the catalog price at publish time, by platform and optional store/country. Requires `price_books:read`.
+   *
+   * `GET /api/v1/price-books`
+   */
+  list(request = {}, requestOptions) {
+    const { organizationId, platform, enabledOnly } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/price-books",
+      query: { organizationId, platform, enabledOnly },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Create Price Book Rule
+     *
+     * Create a marketplace price book rule for a platform (optional store and country). Does not change Omni product prices. Requires `price_books:write`.
+  
+  `expression` is the buyer formula and replaces markup percent. `price` in that formula is the catalog price, not cost price. Without an expression, `marginValue` is the markup percent.
+     *
+     * `POST /api/v1/price-books`
+     */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/price-books",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Delete Price Book Rule
+   *
+   * Delete a marketplace price book rule by ID. Requires `price_books:write`.
+   *
+   * `DELETE /api/v1/price-books/{ruleId}`
+   */
+  delete(request, requestOptions) {
+    const { ruleId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "DELETE",
+      path: `/api/v1/price-books/${encodePathParam("ruleId", ruleId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Get Price Book Rule
+   *
+   * Fetch one marketplace price book rule by ID. Requires `price_books:read`.
+   *
+   * `GET /api/v1/price-books/{ruleId}`
+   */
+  get(request, requestOptions) {
+    const { ruleId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/price-books/${encodePathParam("ruleId", ruleId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Update Price Book Rule
+   *
+   * Update store, country, markup, buyer formula, rounding, currency, or enabled flag for a price book rule. Platform cannot be changed; create a new rule instead. Requires `price_books:write`.
+   *
+   * `PATCH /api/v1/price-books/{ruleId}`
+   */
+  update(request, requestOptions) {
+    const { ruleId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PATCH",
+      path: `/api/v1/price-books/${encodePathParam("ruleId", ruleId)}`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Preview Channel List Price
+   *
+   * Compute channel list price from a canonical list price using matching enabled rules (or a forced ruleId). Requires `price_books:read`.
+   *
+   * `POST /api/v1/price-books/preview`
+   */
+  preview(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/price-books/preview",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var ProductCategoriesClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Recommend Marketplace Product Categories
+   *
+   * Suggest best-fit marketplace categories and category attribute values for a persisted product using semantic taxonomy search. Authenticate with an OmniCommerce API key as `Authorization: Bearer omni_sk_...`.
+   *
+   * `POST /api/v1/manage-product-category/recommend`
+   */
+  recommend(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/manage-product-category/recommend",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var ProductsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Products
+   *
+   * List products for the authenticated organization with optional filters and pagination. Authenticate with an API key or OAuth bearer token. The organization is taken from that credential; do not send `organizationId`.
+   *
+   * `GET /api/v1/products`
+   */
+  list(request = {}, requestOptions) {
+    const {
+      status,
+      marketplace,
+      country,
+      q,
+      sku,
+      minPrice,
+      maxPrice,
+      sortBy,
+      limit,
+      offset
+    } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/products",
+      query: {
+        status,
+        marketplace,
+        country,
+        q,
+        sku,
+        minPrice,
+        maxPrice,
+        sortBy,
+        limit,
+        offset
+      },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Create Product
+     *
+     * Queue a single-product create workflow for the authenticated organization. Product enrichment is disabled by default; set `workflow.enrich` to `true` to enable it.
+  
+  ### Request behavior
+  
+  - `product` contains developer-supplied fields. Unknown fields are preserved as enrichment context.
+  - SKU is the unique product upsert identifier.
+  - Externally hosted HTTP(S) images are copied to managed R2 storage.
+  - `targetMarketplaces` and `targetCountries` are optional; enrichment can run without publishing targets.
+  
+  ### Asynchronous result
+  
+  The API returns a job ID. Poll `GET /api/v1/jobs/{jobId}` for completion. Product creation, image ingestion, enrichment, and taxonomy assignment run in the same product workflow job. ACO generation runs separately when enabled; poll `result.geoJobId` for its comple
+     *
+     * `POST /api/v1/products`
+     */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/products",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Delete Product
+   *
+   * Soft-delete a product by ID. The product will be marked as deleted but not permanently removed. Call again on a deleted product to permanently delete it. Supports API key Bearer token authentication.
+   *
+   * `DELETE /api/v1/products/{productId}`
+   */
+  delete(request, requestOptions) {
+    const { productId } = request ?? {};
+    return this._http.request({
+      method: "DELETE",
+      path: `/api/v1/products/${encodePathParam("productId", productId)}`,
+      query: void 0,
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Get Product
+     *
+     * Retrieve a single product by ID for the authenticated organization.
+  
+  Authenticate with an API key using Bearer token authentication.
+  
+  When available, the response includes generated Agentic Commerce Optimization (ACO) data:
+  
+  - Profile metadata and FAQs
+  - Localization content and cultural notes
+  - Intent queries and signals
+  - Sources and claims
+     *
+     * `GET /api/v1/products/{productId}`
+     */
+  get(request, requestOptions) {
+    const { productId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/products/${encodePathParam("productId", productId)}`,
+      query: void 0,
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Update Product
+   *
+   * Update an existing product by ID. Only provided fields will be updated. Supports API key Bearer token authentication.
+   *
+   * `PATCH /api/v1/products/{productId}`
+   */
+  update(request, requestOptions) {
+    const { productId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PATCH",
+      path: `/api/v1/products/${encodePathParam("productId", productId)}`,
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Update Product Cost
+     *
+     * Set catalog cost for one simple product or variant UUID. Cost is Omni-only and never syncs to marketplaces. Prefer `POST /api/v1/products/cost` for Windmill or other bulk jobs.
+  
+  Requires `catalog:write`. When `costPriceCurrency` differs from the product selling currency and `costPriceFxRate` is omitted, Omni stores an FX quote on the product.
+     *
+     * `PATCH /api/v1/products/{productId}/cost`
+     */
+  updateCost(request, requestOptions) {
+    const { productId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PATCH",
+      path: `/api/v1/products/${encodePathParam("productId", productId)}/cost`,
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Delist Product
+   *
+   * Queue delist for one product on the marketplaces you name. `marketplaces` accepts one or more of shopee, lazada, tiktok, shopify, whatsapp, zalora, amazon, and ebay. Each named marketplace must already have a listing; other channels are left untouched. Omit `marketplaces` to delist every existing listing. This does not delete the OmniCommerce product. Poll GET /api/v1/jobs/{jobId} until data.status is succeeded, partial, or failed. Accepted means the job was queued, not that the marketplace has removed the listing.
+   *
+   * `POST /api/v1/products/{productId}/delist`
+   */
+  delist(request, requestOptions) {
+    const { productId, ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: `/api/v1/products/${encodePathParam("productId", productId)}/delist`,
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Update Product Inventory
+     *
+     * Update canonical on-hand inventory for a simple product or variant UUID. Multi-variant parent products must be updated through their variant IDs. A successful quantity change emits `product.inventory.changed` to matching developer webhook subscriptions.
+  
+  ### Authorization
+  
+  Requires an API credential with `catalog:write`. OmniCommerce derives `organizationId` from that credential; the request body cannot select or override an organization. ERP-managed and multi-source inventory keeps its existing ownership protections.
+  
+  ### Marketplace sync
+  
+  The update is Omni-only by default. Set `syncToMarketplaces` to `true` to create one durable inventory outbox job per marketplace account. Omit `targets` to sync every enabled, published account for the product, or provide exact `{ platform, accountId }
+     *
+     * `PATCH /api/v1/products/{productId}/inventory`
+     */
+  updateInventory(request, requestOptions) {
+    const { productId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PATCH",
+      path: `/api/v1/products/${encodePathParam("productId", productId)}/inventory`,
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Update Product Price
+     *
+     * Update the canonical catalog price for a simple product or variant UUID. Multi-variant parent products must be updated through their variant IDs. A successful change emits `product.price.changed` to matching developer webhook subscriptions.
+  
+  ### Authorization
+  
+  Requires an API credential with `catalog:write`. OmniCommerce derives `organizationId` from that credential; the request body cannot select or override an organization.
+  
+  ### Marketplace sync
+  
+  The update is Omni-only by default. Set `syncToMarketplaces` to `true` to queue durable marketplace work. Omit `targets` to sync every enabled, published account for the product, or provide exact `{ platform, accountId }` targets. Every explicit target is validated before the catalog changes. The response contains pollable job IDs and immediate
+     *
+     * `PATCH /api/v1/products/{productId}/price`
+     */
+  updatePrice(request, requestOptions) {
+    const { productId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PATCH",
+      path: `/api/v1/products/${encodePathParam("productId", productId)}/price`,
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Publish Product
+   *
+   * Queue marketplace publish jobs for a product by productId. OmniCommerce publishes to the marketplaces already enabled on the product and uses the product's store selection or a single/default connected store.
+   *
+   * `POST /api/v1/products/{productId}/publish`
+   */
+  publish(request, requestOptions) {
+    const { productId, ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: `/api/v1/products/${encodePathParam("productId", productId)}/publish`,
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Bulk Import Products from JSON or CSV
+     *
+     * Queue a bulk product import for the authenticated organization.
+  
+  ### Input options
+  
+  - Upload a CSV (2 MiB) or JSON products file (8 MiB) using `multipart/form-data`.
+  - Send JSON with a `products` array of 1–1,000 flat product objects (8 MiB request maximum).
+  - Send JSON with inline `csvText`.
+  - Send JSON referencing a stored `documentId`.
+  
+  ### Asynchronous result
+  
+  The API creates import rows, then queues draft creation and AI Review through Inngest. Completed import jobs expose `reviewBatchIds`, `reviewUrls`, and `reviewWarnings`; generated changes require Review approval. Poll the returned `bulk_...` job with `GET /api/v1/jobs/{jobId}`.
+  
+  Cancel an in-flight import with `POST /api/v1/jobs/{jobId}/cancel`.
+     *
+     * `POST /api/v1/products/bulk-import`
+     */
+  bulkImport(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/products/bulk-import",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Batch Update Product Cost
+     *
+     * Set catalog cost price and currency for one or more products. Cost is Omni-only and never syncs to marketplaces.
+  
+  Each update targets `productId` or `sku` (Omni `products.sku`). Provide `costPrice` with `costPriceCurrency` when the source amount is not in the product selling currency. If `costPriceFxRate` is omitted and the currencies differ, Omni quotes FX via the canonical FX service and stores the rate on the product.
+  
+  ### Authorization
+  
+  Requires `catalog:write`. `organizationId` comes from the credential; the body cannot select an organization.
+  
+  ### Limits
+  
+  `updates` is required, 1–200 items. Duplicate product IDs fail after the first occurrence. `costPrice: null` clears cost and FX.
+     *
+     * `POST /api/v1/products/cost`
+     */
+  updateCosts(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/products/cost",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Queue Product Enrichment
+     *
+     * Requires catalog:enrich. Queue content enrichment for 1–1,000 existing Omni product IDs across all supported marketplaces. Returns 202 after queue submission without awaiting AI completion or publishing.
+  
+  ### Enrichment options
+  
+  Fields, instructions and auto-apply settings use the canonical enrichment service. Exclude name from selectedFields to preserve titles. Weight and dimensions are always included; image and taxonomy workflows are not queued here.
+  
+  autoApplyHighConfidence defaults to false. When enabled, the supplied threshold (0.62–1) or organization threshold applies; low-confidence or blocked proposals remain in Review. AI usage is billed to the authenticated organization. Open links.review to inspect results.
+     *
+     * `POST /api/v1/products/enrich`
+     */
+  enrich(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/products/enrich",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var PromotionsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Promotions
+   *
+   * List central promotions for the authenticated organization with filters and offset pagination matching the workspace Promotions listing. Requires `promotions:read`.
+   *
+   * `GET /api/v1/promotions`
+   */
+  list(request = {}, requestOptions) {
+    const {
+      organizationId,
+      q,
+      status,
+      marketplace,
+      store,
+      sortBy,
+      sortDir,
+      limit,
+      offset
+    } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/promotions",
+      query: {
+        organizationId,
+        q,
+        status,
+        marketplace,
+        store,
+        sortBy,
+        sortDir,
+        limit,
+        offset
+      },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Create Promotion
+   *
+   * Create a central promotion targeting connected stores. Requires `promotions:write`. Fixed-amount discounts resolve currency from the selected store countries.
+   *
+   * `POST /api/v1/promotions`
+   */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/promotions",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Delete Promotion
+   *
+   * Delete a promotion by ID. Requires `promotions:write`.
+   *
+   * `DELETE /api/v1/promotions/{promotionId}`
+   */
+  delete(request, requestOptions) {
+    const { promotionId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "DELETE",
+      path: `/api/v1/promotions/${encodePathParam("promotionId", promotionId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Get Promotion
+   *
+   * Fetch one promotion by ID, including effective status. Requires `promotions:read`.
+   *
+   * `GET /api/v1/promotions/{promotionId}`
+   */
+  get(request, requestOptions) {
+    const { promotionId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/promotions/${encodePathParam("promotionId", promotionId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Update Promotion
+   *
+   * Update promotion fields (name, discount, schedule, status, stores). Requires `promotions:write`.
+   *
+   * `PATCH /api/v1/promotions/{promotionId}`
+   */
+  update(request, requestOptions) {
+    const { promotionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PATCH",
+      path: `/api/v1/promotions/${encodePathParam("promotionId", promotionId)}`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Unassign Products from Promotion
+   *
+   * Remove product assignments and queue marketplace teardown. Requires `promotions:write`.
+   *
+   * `DELETE /api/v1/promotions/{promotionId}/products`
+   */
+  removeProducts(request, requestOptions) {
+    const { promotionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "DELETE",
+      path: `/api/v1/promotions/${encodePathParam("promotionId", promotionId)}/products`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * List Promotion Assignments
+   *
+   * List products assigned to a promotion. Requires `promotions:read`.
+   *
+   * `GET /api/v1/promotions/{promotionId}/products`
+   */
+  listProducts(request, requestOptions) {
+    const { promotionId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/promotions/${encodePathParam("promotionId", promotionId)}/products`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Assign Products to Promotion
+   *
+   * Assign one or more products to a promotion. Creates pending marketplace sync rows; call sync after assign. Requires `promotions:write`.
+   *
+   * `POST /api/v1/promotions/{promotionId}/products`
+   */
+  addProducts(request, requestOptions) {
+    const { promotionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: `/api/v1/promotions/${encodePathParam("promotionId", promotionId)}/products`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Sync Promotion to Marketplaces
+   *
+   * Queue marketplace push for assigned products (Shopee promotion, Lazada Store Flash Sale/voucher/Flexicombo, TikTok activity, or Shopify discount). Requires `promotions:write`.
+   *
+   * `POST /api/v1/promotions/{promotionId}/sync`
+   */
+  sync(request, requestOptions) {
+    const { promotionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: `/api/v1/promotions/${encodePathParam("promotionId", promotionId)}/sync`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var ReturnsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Returns
+   *
+   * List normalized, PII-free marketplace returns with SKU-level lines. Requires `returns:read`. Use updatedSince and cursor for bootstrap/recovery alongside return webhooks.
+   *
+   * `GET /api/v1/returns`
+   */
+  list(request = {}, requestOptions) {
+    const {
+      organizationId,
+      marketplace,
+      accountId,
+      externalOrderId,
+      updatedSince,
+      cursor,
+      limit
+    } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/returns",
+      query: {
+        organizationId,
+        marketplace,
+        accountId,
+        externalOrderId,
+        updatedSince,
+        cursor,
+        limit
+      },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Get Return
+   *
+   * Get one normalized, PII-free return by OmniCommerce UUID. Requires `returns:read`; another organization's return returns 404.
+   *
+   * `GET /api/v1/returns/{returnId}`
+   */
+  get(request, requestOptions) {
+    const { returnId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/returns/${encodePathParam("returnId", returnId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var SearchClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Search Public Merchant Products
+   *
+   * Search across all public merchants and products with optional merchant, pricing, stock, marketplace, and localization filters.
+   *
+   * `GET /api/v1/search`
+   */
+  list(request = {}, requestOptions) {
+    const {
+      q,
+      category,
+      brand,
+      min_price,
+      max_price,
+      in_stock,
+      merchant_ids,
+      sort,
+      platform,
+      country,
+      language,
+      include_intent,
+      limit,
+      offset
+    } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/search",
+      query: {
+        q,
+        category,
+        brand,
+        min_price,
+        max_price,
+        in_stock,
+        merchant_ids,
+        sort,
+        platform,
+        country,
+        language,
+        include_intent,
+        limit,
+        offset
+      },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Search Public Merchant Products
+   *
+   * Search across all public merchants and products with optional merchant, pricing, stock, marketplace, and localization filters.
+   *
+   * `POST /api/v1/search`
+   */
+  query(request = {}, requestOptions) {
+    const {
+      q,
+      category,
+      brand,
+      min_price,
+      max_price,
+      in_stock,
+      merchant_ids,
+      sort,
+      platform,
+      country,
+      language,
+      include_intent,
+      limit,
+      offset,
+      ...body
+    } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/search",
+      query: {
+        q,
+        category,
+        brand,
+        min_price,
+        max_price,
+        in_stock,
+        merchant_ids,
+        sort,
+        platform,
+        country,
+        language,
+        include_intent,
+        limit,
+        offset
+      },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var SettlementsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Settlements
+   *
+   * List the latest normalized order-settlement snapshots created by finance ingestion. Requires `settlements:read`. Use updatedSince and cursor for recovery; money remains partitioned by currency.
+   *
+   * `GET /api/v1/settlements`
+   */
+  list(request = {}, requestOptions) {
+    const {
+      organizationId,
+      marketplace,
+      accountId,
+      orderId,
+      externalOrderId,
+      updatedSince,
+      cursor,
+      limit
+    } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/settlements",
+      query: {
+        organizationId,
+        marketplace,
+        accountId,
+        orderId,
+        externalOrderId,
+        updatedSince,
+        cursor,
+        limit
+      },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Apply Settlements
+     *
+     * Apply marketplace-agnostic settlement lines to existing orders.
+  
+  ### Authentication
+  
+  Requires `orders:write`.
+  
+  ### What this endpoint does
+  
+  - Stores every submitted line as marketplace financial evidence.
+  - Projects **settled** rows into the order finance ledger.
+  - Keeps pending, reversed, and voided rows as evidence only, removing any earlier developer API ledger projection for the same `sourceEventKey`.
+  - Recomputes Payment received when a marketplace-specific formula exists. Zalora is currently supported.
+  
+  ### Order matching
+  
+  Orders are matched by organization, marketplace platform, and exact `externalOrderId`. Include `externalOrderItemId` when an order has multiple lines.
+  
+  - `accountId` is an exact store match, never a wildcard.
+  - `marketplace=zalora` can match Zalora Seller Center or
+     *
+     * `POST /api/v1/settlements`
+     */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/settlements",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Get Settlement
+   *
+   * Get the latest normalized settlement snapshot by stable settlement ID. Requires `settlements:read`.
+   *
+   * `GET /api/v1/settlements/{settlementId}`
+   */
+  get(request, requestOptions) {
+    const { settlementId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/settlements/${encodePathParam("settlementId", settlementId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var SyncClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Sync Product Commercial Fields
+   *
+   * Update price, sale price, or stock quantity in OmniCommerce and queue marketplace sync workers where applicable.
+   *
+   * `POST /api/v1/sync`
+   */
+  run(request = {}, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/sync",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var ThreadsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Get Thread Status
+   *
+   * Poll an AOP execution started by `POST /api/v1/aop/{aopId}/execute`. Requires `aops:read`. Status values are `running`, `completed`, or `failed`.
+   *
+   * `GET /api/v1/threads/{thread_id}/status`
+   */
+  getStatus(request, requestOptions) {
+    const {
+      thread_id: threadId,
+      include_messages,
+      organizationId
+    } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/api/v1/threads/${encodePathParam("thread_id", threadId)}/status`,
+      query: { include_messages, organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var UcpCheckoutSessionsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Create UCP Checkout Session
+   *
+   * Create a UCP shopping checkout session against the authenticated organization. The facade translates UCP line items to native agentic checkout sessions, reserves inventory, and returns a UCP checkout resource. Requires `UCP-Agent` and OAuth `checkout:write`.
+   *
+   * `POST /ucp/v1/checkout-sessions`
+   */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/ucp/v1/checkout-sessions",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Get UCP Checkout Session
+   *
+   * Fetch the current UCP checkout resource for a native agentic checkout session. Requires `UCP-Agent` and bearer authentication.
+   *
+   * `GET /ucp/v1/checkout-sessions/{sessionId}`
+   */
+  get(request, requestOptions) {
+    const { sessionId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/ucp/v1/checkout-sessions/${encodePathParam("sessionId", sessionId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Update UCP Checkout Session
+   *
+   * Update UCP cart, buyer, fulfillment, or payment rail fields. Provided fields are applied to the native checkout session and inventory reservations are refreshed when line items change. Requires `UCP-Agent` and OAuth `checkout:write`.
+   *
+   * `PATCH /ucp/v1/checkout-sessions/{sessionId}`
+   */
+  update(request, requestOptions) {
+    const { sessionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PATCH",
+      path: `/ucp/v1/checkout-sessions/${encodePathParam("sessionId", sessionId)}`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Replace UCP Checkout Session Fields
+   *
+   * UCP-compatible update method. Current behavior matches PATCH: provided fields are applied and omitted fields remain unchanged. Requires `UCP-Agent` and OAuth `checkout:write`.
+   *
+   * `PUT /ucp/v1/checkout-sessions/{sessionId}`
+   */
+  replace(request, requestOptions) {
+    const { sessionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "PUT",
+      path: `/ucp/v1/checkout-sessions/${encodePathParam("sessionId", sessionId)}`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Cancel UCP Checkout Session
+   *
+   * Cancel a ready-for-payment UCP checkout session and release reserved inventory. Requires `UCP-Agent` and OAuth `checkout:write`.
+   *
+   * `POST /ucp/v1/checkout-sessions/{sessionId}/cancel`
+   */
+  cancel(request, requestOptions) {
+    const { sessionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: `/ucp/v1/checkout-sessions/${encodePathParam("sessionId", sessionId)}/cancel`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Complete UCP Checkout Session
+   *
+   * Settle the selected rail and create a native `agentic` order. Settlement failures return HTTP 402 with the checkout still ready for payment. Requires `UCP-Agent` and OAuth `checkout:write`.
+   *
+   * `POST /ucp/v1/checkout-sessions/{sessionId}/complete`
+   */
+  complete(request, requestOptions) {
+    const { sessionId, organizationId, ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: `/ucp/v1/checkout-sessions/${encodePathParam("sessionId", sessionId)}/complete`,
+      query: { organizationId },
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var UcpOrdersClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * Get UCP Order
+   *
+   * Fetch the native OmniCommerce order created by a completed UCP checkout session. Only `agentic` orders are exposed through this facade.
+   *
+   * `GET /ucp/v1/orders/{orderId}`
+   */
+  get(request, requestOptions) {
+    const { orderId, organizationId } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: `/ucp/v1/orders/${encodePathParam("orderId", orderId)}`,
+      query: { organizationId },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var UcpClient = class {
+  constructor(_http) {
+    this._http = _http;
+    this.checkoutSessions = new UcpCheckoutSessionsClient(this._http);
+    this.orders = new UcpOrdersClient(this._http);
+  }
+  _http;
+  checkoutSessions;
+  orders;
+};
+var WebhookEventsClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Webhook Events
+   *
+   * Pull immutable webhook events for recovery or scheduled reconciliation. Requires `webhooks:manage`. Results are organization-scoped and ordered oldest first; continue with the opaque cursor. This is the pull fallback for a receiver that missed push deliveries.
+   *
+   * `GET /api/v1/webhook-events`
+   */
+  list(request = {}, requestOptions) {
+    const { organizationId, eventType, occurredSince, cursor, limit } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/webhook-events",
+      query: { organizationId, eventType, occurredSince, cursor, limit },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var WebhooksClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+   * List Developer Webhooks
+   *
+   * List configured developer webhook subscriptions for the authenticated organization.
+   *
+   * `GET /api/v1/webhooks`
+   */
+  list(requestOptions) {
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/webhooks",
+      query: void 0,
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+   * Create Developer Webhook
+   *
+   * Create a developer webhook subscription for the authenticated organization. The signing secret is returned only once.
+   *
+   * `POST /api/v1/webhooks`
+   */
+  create(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/webhooks",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var ZaloraClient = class {
+  constructor(_http) {
+    this._http = _http;
+  }
+  _http;
+  /**
+     * Get Selected Zalora Import Status
+     *
+     * Requires catalog:read. Follow the unchanged links.job URL returned by POST. Reads current state once without waiting.
+  
+  ### Completion
+  
+  data.status is pending, running, success, or error; data.terminal and data.success identify completion. data.productIds contains mapped Omni IDs for the supplied product sets. Failed imports remain explicit, including missingExternalIds. The top-level completed status describes this status request, not the import.
+  
+  Keep the original target IDs: the status lookup resolves those targets and does not prove that a modified selection was part of this job.
+     *
+     * `GET /api/v1/zalora/import`
+     */
+  getImport(request, requestOptions) {
+    const { organizationId, jobId, storeId, productSetIds } = request ?? {};
+    return this._http.request({
+      method: "GET",
+      path: "/api/v1/zalora/import",
+      query: { organizationId, jobId, storeId, productSetIds },
+      body: void 0,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+  /**
+     * Import Selected Zalora Products
+     *
+     * Requires catalog:write. Queue an exact import of 1–25 Zalora productSetIds from a connected store. Omit storeId only when one store or one default store is unambiguous.
+  
+  Returns 202 with links.job for optional status checks and retrieval of Omni product IDs. Only one import may run per store at a time. This endpoint does not invoke an AOP, enrich products, or publish listings.
+     *
+     * `POST /api/v1/zalora/import`
+     */
+  importProducts(request, requestOptions) {
+    const { ...body } = request ?? {};
+    return this._http.request({
+      method: "POST",
+      path: "/api/v1/zalora/import",
+      query: void 0,
+      body,
+      ...mergeRequestOptions(requestOptions)
+    });
+  }
+};
+var OmniGeneratedClient = class {
+  constructor(_http) {
+    this._http = _http;
+    this.aop = new AopClient(this._http);
+    this.api = new ApiClient(this._http);
+    this.catalog = new CatalogClient(this._http);
+    this.checkoutSessions = new CheckoutSessionsClient(this._http);
+    this.compare = new CompareClient(this._http);
+    this.directory = new DirectoryClient(this._http);
+    this.evaluate = new EvaluateClient(this._http);
+    this.feed = new FeedClient(this._http);
+    this.images = new ImagesClient(this._http);
+    this.jobs = new JobsClient(this._http);
+    this.looks = new LooksClient(this._http);
+    this.marketplaces = new MarketplacesClient(this._http);
+    this.merchants = new MerchantsClient(this._http);
+    this.monitor = new MonitorClient(this._http);
+    this.oauth = new OauthClient(this._http);
+    this.orders = new OrdersClient(this._http);
+    this.organizations = new OrganizationsClient(this._http);
+    this.priceBooks = new PriceBooksClient(this._http);
+    this.productCategories = new ProductCategoriesClient(this._http);
+    this.products = new ProductsClient(this._http);
+    this.promotions = new PromotionsClient(this._http);
+    this.returns = new ReturnsClient(this._http);
+    this.search = new SearchClient(this._http);
+    this.settlements = new SettlementsClient(this._http);
+    this.sync = new SyncClient(this._http);
+    this.threads = new ThreadsClient(this._http);
+    this.ucp = new UcpClient(this._http);
+    this.webhookEvents = new WebhookEventsClient(this._http);
+    this.webhooks = new WebhooksClient(this._http);
+    this.zalora = new ZaloraClient(this._http);
+  }
+  _http;
+  aop;
+  api;
+  catalog;
+  checkoutSessions;
+  compare;
+  directory;
+  evaluate;
+  feed;
+  images;
+  jobs;
+  looks;
+  marketplaces;
+  merchants;
+  monitor;
+  oauth;
+  orders;
+  organizations;
+  priceBooks;
+  productCategories;
+  products;
+  promotions;
+  returns;
+  search;
+  settlements;
+  sync;
+  threads;
+  ucp;
+  webhookEvents;
+  webhooks;
+  zalora;
+};
+
+// src/Client.ts
+var OmniClient = class extends OmniGeneratedClient {
+  constructor(options = {}) {
+    super(new OmniHttp(normalizeClientOptions(options)));
+  }
+  request(init) {
+    return this._http.request(init);
+  }
+};
+
+// src/webhooks.ts
+var encoder = new TextEncoder();
+var WEBHOOK_SIGNATURE_HEADER = "x-omni-signature";
+var WEBHOOK_TIMESTAMP_HEADER = "x-omni-timestamp";
+var WEBHOOK_EVENT_ID_HEADER = "x-omni-event-id";
+var WEBHOOK_EVENT_TYPE_HEADER = "x-omni-event-type";
+function headerValue(headers, name) {
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    return headers.get(name) ?? headers.get(name.toLowerCase()) ?? void 0;
+  }
+  const record = headers;
+  const direct = record[name] ?? record[name.toLowerCase()];
+  if (Array.isArray(direct)) return direct[0];
+  return direct ?? void 0;
+}
+function toHex(bytes) {
+  return [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function timingSafeEqual(left, right) {
+  if (left.length !== right.length) return false;
+  let mismatch = 0;
+  for (let i = 0; i < left.length; i++) {
+    mismatch |= left.charCodeAt(i) ^ right.charCodeAt(i);
+  }
+  return mismatch === 0;
+}
+async function signWebhookPayload(input) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(input.secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    encoder.encode(`${input.timestamp}.${input.payload}`)
+  );
+  return toHex(signature);
+}
+async function verifyWebhookSignature(input) {
+  const expected = await signWebhookPayload(input);
+  return timingSafeEqual(expected.toLowerCase(), input.signature.toLowerCase());
+}
+async function constructEvent(payload, headers, secret, options) {
+  const rawBody = typeof payload === "string" ? payload : new TextDecoder().decode(payload);
+  const signature = headerValue(headers, WEBHOOK_SIGNATURE_HEADER);
+  const timestampRaw = headerValue(headers, WEBHOOK_TIMESTAMP_HEADER);
+  if (!signature || !timestampRaw) {
+    throw new Error(
+      "Webhook signature verification failed: missing X-Omni-Signature or X-Omni-Timestamp."
+    );
+  }
+  const timestamp = Number(timestampRaw);
+  if (!Number.isFinite(timestamp)) {
+    throw new Error(
+      "Webhook signature verification failed: invalid timestamp."
+    );
+  }
+  const tolerance = options?.toleranceInSeconds ?? 300;
+  const now = Math.floor(Date.now() / 1e3);
+  if (Math.abs(now - timestamp) > tolerance) {
+    throw new Error(
+      "Webhook signature verification failed: timestamp outside tolerance."
+    );
+  }
+  const valid = await verifyWebhookSignature({
+    secret,
+    timestamp,
+    payload: rawBody,
+    signature
+  });
+  if (!valid) {
+    throw new Error(
+      "Webhook signature verification failed: invalid signature."
+    );
+  }
+  let parsed = rawBody;
+  try {
+    parsed = JSON.parse(rawBody);
+  } catch {
+    throw new Error("Webhook signature verification failed: body is not JSON.");
+  }
+  return {
+    eventId: headerValue(headers, WEBHOOK_EVENT_ID_HEADER),
+    eventType: headerValue(headers, WEBHOOK_EVENT_TYPE_HEADER),
+    timestamp,
+    payload: parsed,
+    rawBody
+  };
+}
+
+// src/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  OmniGeneratedClient: () => OmniGeneratedClient
+});
+
+export { BadGatewayError, BadRequestError, ForbiddenError, HttpResponsePromise, InternalServerError, JobFailedError, NotFoundError, api_exports as Omni, OmniClient, OmniEnvironment, OmniError, OmniTimeoutError, SDK_VERSION, ServiceUnavailableError, TooManyRequestsError, UnauthorizedError, UnprocessableEntityError, WEBHOOK_EVENT_ID_HEADER, WEBHOOK_EVENT_TYPE_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, constructEvent, signWebhookPayload, verifyWebhookSignature };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map