@01.software/sdk 0.44.0 → 0.46.0

package/dist/query.js

@@ -84,8 +84,14 @@ function canonicalProductListingPageParams(params = {}, limit) {
     canonicalFilters.availableForSale = filters.availableForSale;
   }
   const search = params.search?.trim();
+  const market = params.market?.trim();
   return {
     mode: params.mode ?? "catalog",
+    ...market && { market },
+    ...params.locale != null && { locale: params.locale },
+    ...params.fallbackLocale !== void 0 && {
+      fallbackLocale: params.fallbackLocale
+    },
     ...params.page != null && { page: params.page },
     ...limit != null ? { limit } : params.limit != null ? { limit: params.limit } : {},
     ...search && { search },
@@ -94,13 +100,50 @@ function canonicalProductListingPageParams(params = {}, limit) {
       filters: canonicalFilters
     },
     ...params.basePath != null && { basePath: params.basePath },
-    ...params.trailingSlash != null && { trailingSlash: params.trailingSlash },
+    ...params.trailingSlash != null && {
+      trailingSlash: params.trailingSlash
+    },
     ...params.emit != null && { emit: params.emit },
     ...params.preferCompleteVariantFromHint != null && {
       preferCompleteVariantFromHint: params.preferCompleteVariantFromHint
     }
   };
 }
+function canonicalMarket(value) {
+  const market = value?.trim();
+  return market || void 0;
+}
+function canonicalProductListingGroupsQueryOptions(options, limit) {
+  const { market: rawMarket, ...rest } = options ?? {};
+  const market = canonicalMarket(rawMarket);
+  const canonical = {
+    ...rest,
+    ...limit !== void 0 ? { limit } : {},
+    ...market ? { market } : {}
+  };
+  return Object.keys(canonical).length > 0 ? canonical : void 0;
+}
+function canonicalProductDetailParams(params) {
+  const market = params.market?.trim();
+  const localeOptions = {
+    ...params.locale != null && { locale: params.locale },
+    ...params.fallbackLocale !== void 0 && {
+      fallbackLocale: params.fallbackLocale
+    }
+  };
+  if ("slug" in params) {
+    return {
+      slug: params.slug,
+      ...market ? { market } : {},
+      ...localeOptions
+    };
+  }
+  return {
+    id: params.id,
+    ...market ? { market } : {},
+    ...localeOptions
+  };
+}
 function collectionKeys(collection) {
   return {
     all: [collection],
@@ -121,22 +164,36 @@ var customerKeys = {
   me: () => ["customer", "me"]
 };
 var productKeys = {
-  listingGroups: (options) => ["products", "listing-groups", "list", options],
-  listingGroupsCatalog: (options) => ["products", "listing-groups", "catalog", options],
+  listingGroups: (options) => [
+    "products",
+    "listing-groups",
+    "list",
+    canonicalProductListingGroupsQueryOptions(options)
+  ],
+  listingGroupsCatalog: (options) => [
+    "products",
+    "listing-groups",
+    "catalog",
+    canonicalProductListingGroupsQueryOptions(options)
+  ],
   listingGroupsInfinite: (options, pageSize) => [
     "products",
     "listing-groups",
     "infinite",
-    pageSize === void 0 ? options : { ...options, limit: pageSize }
+    canonicalProductListingGroupsQueryOptions(options, pageSize)
   ],
   listingGroupsCatalogInfinite: (options, pageSize) => [
     "products",
     "listing-groups",
     "catalog",
     "infinite",
-    pageSize === void 0 ? options : { ...options, limit: pageSize }
+    canonicalProductListingGroupsQueryOptions(options, pageSize)
+  ],
+  listingPage: (params) => [
+    "products",
+    "listing-page",
+    canonicalProductListingPageParams(params)
   ],
-  listingPage: (params) => ["products", "listing-page", canonicalProductListingPageParams(params)],
   listingPageInfinite: (params, pageSize) => [
     "products",
     "listing-page",
@@ -146,7 +203,7 @@ var productKeys = {
       pageSize
     )
   ],
-  detail: (params) => ["products", "detail", params],
+  detail: (params) => ["products", "detail", canonicalProductDetailParams(params)],
   detailAll: () => ["products", "detail"]
 };
 
@@ -444,10 +501,74 @@ var SDKError = class extends Error {
       details: this.details,
       userMessage: this.userMessage,
       suggestion: this.suggestion,
-      ...this.requestId !== void 0 && { requestId: this.requestId }
+      ...this.requestId !== void 0 && { requestId: this.requestId },
+      ...this.kind !== void 0 && { kind: this.kind },
+      ...this.reason !== void 0 && { reason: this.reason },
+      ...this.rawReason !== void 0 && { rawReason: this.rawReason },
+      ...this.retryable !== void 0 && { retryable: this.retryable },
+      ...this.retryAfter !== void 0 && { retryAfter: this.retryAfter }
     };
   }
 };
+var COMMERCE_ERROR_CODES = [
+  "validation_failed",
+  "unauthorized",
+  "forbidden",
+  "token_expired",
+  "origin_not_allowed",
+  "server_credentials_required",
+  "not_found",
+  "conflict",
+  "cart_revision_conflict",
+  "rate_limit_exceeded",
+  "usage_limit_exceeded",
+  "service_unavailable",
+  "idempotency_conflict",
+  "idempotency_in_progress",
+  "cart_not_active",
+  "cart_locked",
+  "cart_empty",
+  "cart_market_unavailable",
+  "cart_market_mismatch",
+  "checkout_not_open",
+  "payment_slot_held",
+  "reservation_expired",
+  "payment_session_not_cancelable",
+  "provider_identity_mismatch",
+  "provider_unavailable",
+  "lock_timeout",
+  "price_changed",
+  "pricing_fact_in_use",
+  "insufficient_stock",
+  "market_not_found",
+  "market_shipping_currency_unsupported",
+  "missing_market_rate",
+  "missing_shipping_amount",
+  "no_enabled_payment_provider",
+  "product_market_unavailable",
+  "unsupported_currency",
+  "missing_price_row",
+  "payment_provider_currency_unsupported",
+  "discount_code_not_found",
+  "discount_not_started",
+  "discount_expired",
+  "discount_usage_limit",
+  "discount_per_customer_limit",
+  "discount_customer_required",
+  "discount_first_order_only",
+  "discount_customer_not_eligible",
+  "discount_customer_excluded",
+  "discount_items_required",
+  "discount_product_not_eligible",
+  "discount_product_excluded",
+  "discount_min_order_amount",
+  "discount_currency_scope_required",
+  "discount_allocation_method_unsupported",
+  "currency_mismatch"
+];
+var COMMERCE_ERROR_CODE_SET = new Set(
+  COMMERCE_ERROR_CODES
+);
 var ConfigError = class extends SDKError {
   constructor(message, details, userMessage, suggestion) {
     super("CONFIG_ERROR", message, void 0, details, userMessage, suggestion);
@@ -577,100 +698,387 @@ import {
   useSuspenseQuery as useSuspenseQueryOriginal2
 } from "@tanstack/react-query";
 
-// src/core/api/endpoints.ts
-var COMMERCE_ENDPOINTS = {
+// src/core/internal/utils/query-string.ts
+function normalizedMarket(value) {
+  const market = value?.trim();
+  return market || void 0;
+}
+function appendProductLocaleSearchParams(search, options) {
+  if (options?.locale) search.set("locale", options.locale);
+  if (options?.fallbackLocale !== void 0) {
+    search.set(
+      "fallbackLocale",
+      options.fallbackLocale === false ? "none" : options.fallbackLocale
+    );
+  }
+}
+function appendListingGroupsQuerySearchParams(search, options) {
+  const market = normalizedMarket(options?.market);
+  if (market) search.set("market", market);
+  appendProductLocaleSearchParams(search, options);
+  if (options?.page != null) search.set("page", String(options.page));
+  if (options?.limit != null) search.set("limit", String(options.limit));
+  if (options?.sort != null) {
+    const sort = options.sort;
+    search.set("sort", Array.isArray(sort) ? sort.join(",") : sort);
+  }
+  if (options?.where != null) {
+    search.set("whereJson", JSON.stringify(options.where));
+  }
+}
+function listingPageSearchParams(options) {
+  const search = new URLSearchParams();
+  appendListingGroupsQuerySearchParams(search, options);
+  return search.toString();
+}
+
+// ../../internal/http-contracts/src/index.ts
+var operationBrand = /* @__PURE__ */ Symbol("sdk-http-operation");
+var operation = (collection, method, path) => Object.freeze({
+  [operationBrand]: true,
+  collection,
+  method,
+  path
+});
+var COMMERCE_ENDPOINT_OPERATIONS = {
+  products: {
+    detail: operation("products", "get", "/detail"),
+    detailCatalog: operation("products", "get", "/detail/catalog"),
+    listingGroups: operation("products", "get", "/listing-groups"),
+    listingGroupsCatalog: operation(
+      "products",
+      "get",
+      "/listing-groups/catalog"
+    ),
+    listingGroupsQuery: operation("products", "post", "/listing-groups/query"),
+    listingGroupsQueryGet: operation(
+      "products",
+      "get",
+      "/listing-groups/query"
+    ),
+    listingGroupsQueryCatalog: operation(
+      "products",
+      "get",
+      "/listing-groups/query/catalog"
+    ),
+    stockCheck: operation("products", "post", "/stock-check"),
+    stockSnapshot: operation("products", "get", "/stock"),
+    upsert: operation("products", "post", "/upsert")
+  },
   orders: {
-    create: "/api/orders/create",
-    update: "/api/orders/update",
-    confirmPayment: "/api/orders/confirm-payment",
-    byPayment: "/api/orders/by-payment",
-    cancel: "/api/orders/cancel",
-    resolveCancelRefund: "/api/orders/resolve-cancel-refund",
-    checkout: "/api/orders/checkout",
-    createFulfillment: "/api/orders/create-fulfillment",
-    updateFulfillment: "/api/orders/update-fulfillment"
+    create: operation("orders", "post", "/create"),
+    update: operation("orders", "post", "/update"),
+    confirmPayment: operation("orders", "post", "/confirm-payment"),
+    byPayment: operation("orders", "get", "/by-payment"),
+    cancel: operation("orders", "post", "/cancel"),
+    resolveCancelRefund: operation("orders", "post", "/resolve-cancel-refund"),
+    checkout: operation("orders", "post", "/checkout"),
+    createFulfillment: operation("orders", "post", "/create-fulfillment"),
+    updateFulfillment: operation("orders", "post", "/update-fulfillment")
+  },
+  checkouts: {
+    detail: operation("checkouts", "post", "/detail"),
+    query: operation("checkouts", "post", "/query")
   },
   transactions: {
-    update: "/api/transactions/update"
+    update: operation("transactions", "post", "/update")
   },
   returns: {
-    create: "/api/returns/create",
-    update: "/api/returns/update",
-    returnRefund: "/api/returns/return-refund"
+    create: operation("returns", "post", "/create"),
+    update: operation("returns", "post", "/update"),
+    returnRefund: operation("returns", "post", "/return-refund")
   },
   fulfillmentOrders: {
-    prepare: "/api/fulfillment-orders/prepare-fulfillment-order"
+    prepare: operation(
+      "fulfillment-orders",
+      "post",
+      "/prepare-fulfillment-order"
+    )
   },
   fulfillments: {
-    bulkImport: "/api/fulfillments/bulk-import"
+    bulkImport: operation("fulfillments", "post", "/bulk-import")
   },
   carts: {
-    mine: "/api/carts/mine",
-    merge: "/api/carts/merge",
-    addItem: "/api/carts/add-item",
-    updateItem: "/api/carts/update-item",
-    removeItem: "/api/carts/remove-item",
-    applyDiscount: "/api/carts/apply-discount",
-    removeDiscount: "/api/carts/remove-discount",
-    clear: "/api/carts/clear"
+    create: operation("carts", "post", "/create"),
+    retrieve: operation("carts", "post", "/retrieve"),
+    mine: operation("carts", "post", "/mine"),
+    merge: operation("carts", "post", "/merge"),
+    addItem: operation("carts", "post", "/add-item"),
+    updateItem: operation("carts", "post", "/update-item"),
+    removeItem: operation("carts", "post", "/remove-item"),
+    updateDiscountCodes: operation("carts", "post", "/update-discount-codes"),
+    updateAttributes: operation("carts", "post", "/update-attributes"),
+    clear: operation("carts", "post", "/clear")
   },
-  products: {
-    stockCheck: "/api/products/stock-check",
-    stockSnapshot: "/api/products/stock",
-    listingGroups: "/api/products/listing-groups",
-    listingGroupsCatalog: "/api/products/listing-groups/catalog",
-    listingGroupsQuery: "/api/products/listing-groups/query",
-    listingGroupsQueryCatalog: "/api/products/listing-groups/query/catalog",
-    detail: "/api/products/detail",
-    detailCatalog: "/api/products/detail/catalog",
-    upsert: "/api/products/upsert"
+  paymentSessions: {
+    create: operation("payment-sessions", "post", "/create"),
+    retrieve: operation("payment-sessions", "post", "/retrieve"),
+    cancel: operation("payment-sessions", "post", "/cancel"),
+    server: {
+      create: operation("payment-sessions", "post", "/server/create"),
+      retrieve: operation("payment-sessions", "post", "/server/retrieve"),
+      cancel: operation("payment-sessions", "post", "/server/cancel"),
+      confirm: operation("payment-sessions", "post", "/server/confirm")
+    },
+    custom: {
+      create: operation("orders", "post", "/custom-payment-sessions"),
+      confirm: operation("orders", "post", "/custom-payment-sessions/confirm")
+    }
+  },
+  shippingPolicies: {
+    calculate: operation("shipping-policies", "post", "/calculate")
+  },
+  discounts: {
+    validate: operation("discounts", "post", "/validate")
   }
 };
-var COMMERCE_ENDPOINT_PATHS = Object.values(
-  COMMERCE_ENDPOINTS
-).flatMap((group) => Object.values(group));
-
-// src/core/internal/utils/query-string.ts
-function appendListingGroupsQuerySearchParams(search, options) {
-  if (options?.page != null) search.set("page", String(options.page));
-  if (options?.limit != null) search.set("limit", String(options.limit));
-  if (options?.sort != null) {
-    const sort = options.sort;
-    search.set("sort", Array.isArray(sort) ? sort.join(",") : sort);
+var MEMBERSHIP_ENDPOINT_OPERATIONS = {
+  subscribe: operation(null, "post", "/memberships/subscribe"),
+  cancel: operation(null, "post", "/memberships/:id/cancel"),
+  me: operation(null, "get", "/memberships/me")
+};
+var EVENTS_ENDPOINT_OPERATIONS = {
+  occurrences: {
+    range: operation("event-occurrences", "get", "/range"),
+    admissionAvailability: operation(
+      "event-occurrences",
+      "get",
+      "/admission-availability"
+    )
   }
-  if (options?.where != null) {
-    search.set("whereJson", JSON.stringify(options.where));
+};
+function resolveOperationTemplate(descriptor) {
+  return descriptor.collection ? `/api/${descriptor.collection}${descriptor.path}` : `/api${descriptor.path}`;
+}
+function resolveOperationPath(descriptor, options) {
+  const path = resolveOperationTemplate(descriptor).replace(
+    /:([A-Za-z][A-Za-z0-9_]*)/g,
+    (_, key) => {
+      const value = options?.pathParams?.[key];
+      if (value === void 0) {
+        throw new TypeError(`Missing path parameter: ${key}`);
+      }
+      return encodeURIComponent(value);
+    }
+  );
+  const unresolved = path.match(/:([A-Za-z][A-Za-z0-9_]*)/);
+  if (unresolved) {
+    throw new TypeError(`Missing path parameter: ${unresolved[1]}`);
   }
+  const query = options?.query?.toString().replace(/^\?/, "");
+  return query ? `${path}?${query}` : path;
 }
-function listingGroupsQueryCatalogUrl(options) {
-  const search = new URLSearchParams();
-  appendListingGroupsQuerySearchParams(search, options);
-  const query = search.toString();
-  return `${COMMERCE_ENDPOINTS.products.listingGroupsQueryCatalog}${query ? `?${query}` : ""}`;
+
+// src/core/api/endpoints.ts
+var endpoint = (method, path) => ({ method, path });
+var sharedEndpoint = (descriptor) => descriptor;
+function resolveOperationPath2(descriptor, options) {
+  if ("collection" in descriptor) {
+    return resolveOperationPath(descriptor, options);
+  }
+  const query = options?.query?.toString().replace(/^\?/, "");
+  return query ? `${descriptor.path}?${query}` : descriptor.path;
+}
+var COMMERCE_ENDPOINTS = {
+  products: {
+    detail: endpoint("GET", "/api/products/detail"),
+    detailCatalog: endpoint("GET", "/api/products/detail/catalog"),
+    listingGroups: endpoint("GET", "/api/products/listing-groups"),
+    listingGroupsCatalog: endpoint(
+      "GET",
+      "/api/products/listing-groups/catalog"
+    ),
+    listingGroupsQuery: endpoint("GET", "/api/products/listing-groups/query"),
+    listingGroupsQueryCatalog: endpoint(
+      "GET",
+      "/api/products/listing-groups/query/catalog"
+    ),
+    stockCheck: endpoint("POST", "/api/products/stock-check"),
+    stockSnapshot: endpoint("GET", "/api/products/stock"),
+    upsert: endpoint("POST", "/api/products/upsert")
+  },
+  orders: {
+    update: endpoint("POST", "/api/orders/update"),
+    byPayment: endpoint("GET", "/api/orders/by-payment"),
+    cancel: endpoint("POST", "/api/orders/cancel"),
+    resolveCancelRefund: endpoint("POST", "/api/orders/resolve-cancel-refund"),
+    createFulfillment: endpoint("POST", "/api/orders/create-fulfillment"),
+    updateFulfillment: endpoint("POST", "/api/orders/update-fulfillment")
+  },
+  checkouts: {
+    create: endpoint("POST", "/api/orders/checkout"),
+    retrieve: endpoint("POST", "/api/checkouts/detail"),
+    server: {
+      create: endpoint("POST", "/api/orders/checkout"),
+      retrieve: endpoint("POST", "/api/checkouts/detail"),
+      query: endpoint("POST", "/api/checkouts/query")
+    }
+  },
+  returns: {
+    create: endpoint("POST", "/api/returns/create"),
+    update: endpoint("POST", "/api/returns/update"),
+    returnRefund: endpoint("POST", "/api/returns/return-refund")
+  },
+  fulfillmentOrders: {
+    prepare: endpoint(
+      "POST",
+      "/api/fulfillment-orders/prepare-fulfillment-order"
+    )
+  },
+  fulfillments: {
+    bulkImport: endpoint("POST", "/api/fulfillments/bulk-import")
+  },
+  carts: {
+    create: endpoint("POST", "/api/carts/create"),
+    retrieve: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.retrieve),
+    mine: endpoint("POST", "/api/carts/mine"),
+    merge: endpoint("POST", "/api/carts/merge"),
+    server: {
+      // Server credentials are an authorization lane, not a second Cart
+      // transport. These must stay bound to the registered shared operations.
+      create: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.create),
+      retrieve: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.retrieve),
+      mine: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.mine),
+      merge: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.merge),
+      addItem: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.addItem),
+      updateItem: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.updateItem),
+      removeItem: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.removeItem),
+      updateDiscountCodes: sharedEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.carts.updateDiscountCodes
+      ),
+      updateAttributes: sharedEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.carts.updateAttributes
+      ),
+      clear: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.clear)
+    },
+    addItem: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.addItem),
+    updateItem: endpoint("POST", "/api/carts/update-item"),
+    removeItem: endpoint("POST", "/api/carts/remove-item"),
+    updateDiscountCodes: endpoint("POST", "/api/carts/update-discount-codes"),
+    updateAttributes: endpoint("POST", "/api/carts/update-attributes"),
+    clear: endpoint("POST", "/api/carts/clear")
+  },
+  paymentSessions: {
+    create: endpoint("POST", "/api/payment-sessions/create"),
+    retrieve: endpoint("POST", "/api/payment-sessions/retrieve"),
+    cancel: endpoint("POST", "/api/payment-sessions/cancel"),
+    custom: {
+      create: sharedEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.custom.create
+      ),
+      confirm: sharedEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.custom.confirm
+      )
+    },
+    server: {
+      create: endpoint("POST", "/api/payment-sessions/server/create"),
+      retrieve: endpoint("POST", "/api/payment-sessions/server/retrieve"),
+      cancel: endpoint("POST", "/api/payment-sessions/server/cancel"),
+      confirm: endpoint("POST", "/api/payment-sessions/server/confirm")
+    }
+  },
+  shippingPolicies: {
+    calculate: endpoint("POST", "/api/shipping-policies/calculate")
+  }
+};
+function isCommerceEndpointDescriptor(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.method === "string" && typeof candidate.path === "string";
 }
+function flattenEndpointPaths(value) {
+  if (isCommerceEndpointDescriptor(value)) return [resolveOperationPath2(value)];
+  if (!value || typeof value !== "object") return [];
+  return Object.values(value).flatMap((entry) => flattenEndpointPaths(entry));
+}
+function flattenEndpointDescriptors(value) {
+  if (isCommerceEndpointDescriptor(value)) return [value];
+  if (!value || typeof value !== "object") return [];
+  return Object.values(value).flatMap(
+    (entry) => flattenEndpointDescriptors(entry)
+  );
+}
+var COMMERCE_ENDPOINT_PATHS = flattenEndpointPaths(COMMERCE_ENDPOINTS);
+var COMMERCE_ENDPOINT_DESCRIPTORS = flattenEndpointDescriptors(COMMERCE_ENDPOINTS);
+var MEMBERSHIP_ENDPOINTS = {
+  subscribe: "/api/memberships/subscribe",
+  cancel: (id) => `/api/memberships/${id}/cancel`,
+  me: "/api/memberships/me"
+};
+var MEMBERSHIP_ENDPOINT_PATHS = [
+  MEMBERSHIP_ENDPOINTS.subscribe,
+  MEMBERSHIP_ENDPOINTS.cancel(":id"),
+  MEMBERSHIP_ENDPOINTS.me
+];
 
 // src/core/query/query-hooks.ts
-var LISTING_GROUPS_QUERY_PATH = COMMERCE_ENDPOINTS.products.listingGroupsQuery;
+function normalizeMarket(market) {
+  const normalized = market?.trim();
+  return normalized || void 0;
+}
+function requestCommerceFindEndpoint(collectionClient, endpoint2, options) {
+  const path = resolveOperationPath2(endpoint2, { query: options?.query });
+  if (endpoint2.method === "get") {
+    return collectionClient.requestFindEndpointGet(path);
+  }
+  if (endpoint2.method === "post") {
+    return collectionClient.requestFindEndpoint(path, options?.data);
+  }
+  throw new TypeError(`Unsupported find endpoint method: ${endpoint2.method}`);
+}
+function withDefaultMarket(params, market) {
+  const defaultMarket = normalizeMarket(market);
+  if (!defaultMarket || normalizeMarket(params?.market)) return params;
+  return { ...params ?? {}, market: defaultMarket };
+}
+function resolveProductMarket(commerceClient, context) {
+  return normalizeMarket(context?.market) ?? normalizeMarket(commerceClient.getDefaultMarket?.());
+}
+function splitListingGroupsQueryOptions(queryOptions) {
+  const normalized = canonicalProductListingGroupsQueryOptions(queryOptions);
+  if (!normalized) return { market: void 0, options: void 0 };
+  const { market, ...options } = normalized;
+  return {
+    market,
+    options: Object.keys(options).length > 0 ? options : void 0
+  };
+}
 function fetchProductListingGroupsQuery(collectionClient, queryOptions) {
-  return collectionClient.requestFindEndpoint(
-    LISTING_GROUPS_QUERY_PATH,
-    { options: queryOptions }
+  const { market, options } = splitListingGroupsQueryOptions(queryOptions);
+  return requestCommerceFindEndpoint(
+    collectionClient,
+    COMMERCE_ENDPOINT_OPERATIONS.products.listingGroupsQuery,
+    {
+      data: {
+        ...market ? { market } : {},
+        ...options ? { options } : {}
+      }
+    }
   );
 }
 function fetchProductListingGroupsCatalogQuery(collectionClient, queryOptions) {
-  return collectionClient.requestFindEndpointGet(
-    listingGroupsQueryCatalogUrl(queryOptions)
+  return requestCommerceFindEndpoint(
+    collectionClient,
+    COMMERCE_ENDPOINT_OPERATIONS.products.listingGroupsQueryCatalog,
+    { query: listingPageSearchParams(queryOptions) }
   );
 }
-function productListingPageQueryOptions(commerceClient, params = {}) {
+function productListingPageQueryOptions(commerceClient, params = {}, context) {
+  const effectiveParams = withDefaultMarket(
+    params,
+    resolveProductMarket(
+      commerceClient,
+      context
+    )
+  ) ?? params;
   return {
-    queryKey: productKeys.listingPage(params),
+    queryKey: productKeys.listingPage(effectiveParams),
     queryFn: () => commerceClient.product.listingPage(
-      params
+      effectiveParams
     )
   };
 }
-function productListingPageInfiniteQueryOptions(commerceClient, params = {}) {
+function productListingPageInfiniteQueryOptions(commerceClient, params = {}, context) {
   const {
     pageSize: explicitPageSize,
     page: _page,
@@ -678,10 +1086,20 @@ function productListingPageInfiniteQueryOptions(commerceClient, params = {}) {
     ...pageParams
   } = params;
   const pageSize = explicitPageSize ?? 20;
+  const effectivePageParams = withDefaultMarket(
+    pageParams,
+    resolveProductMarket(
+      commerceClient,
+      context
+    )
+  ) ?? pageParams;
   return {
-    queryKey: productKeys.listingPageInfinite(pageParams, explicitPageSize),
+    queryKey: productKeys.listingPageInfinite(
+      effectivePageParams,
+      explicitPageSize
+    ),
     queryFn: ({ pageParam }) => commerceClient.product.listingPage({
-      ...pageParams,
+      ...effectivePageParams,
       page: pageParam,
       limit: pageSize
     }),
@@ -689,27 +1107,29 @@ function productListingPageInfiniteQueryOptions(commerceClient, params = {}) {
     getNextPageParam: (lastPage) => lastPage.hasNextPage ? lastPage.nextPage : void 0
   };
 }
-function prefetchProductListingPage(queryClient, commerceClient, params = {}, options) {
+function prefetchProductListingPage(queryClient, commerceClient, params = {}, options, context) {
   return queryClient.prefetchQuery({
     ...productListingPageQueryOptions(
       commerceClient,
-      params
+      params,
+      context
     ),
     ...options
   });
 }
-function prefetchInfiniteProductListingPage(queryClient, commerceClient, params = {}, options) {
+function prefetchInfiniteProductListingPage(queryClient, commerceClient, params = {}, options, context) {
   return queryClient.prefetchInfiniteQuery({
     ...productListingPageInfiniteQueryOptions(
       commerceClient,
-      params
+      params,
+      context
     ),
     pages: options?.pages ?? 1,
     staleTime: options?.staleTime
   });
 }
 var QueryHooks = class extends CollectionHooks {
-  constructor(queryClient, collectionClient, customerAuth, commerceClient) {
+  constructor(queryClient, collectionClient, customerAuth, commerceClient, market) {
     super(queryClient, collectionClient);
     // --- Customer hooks delegation ---
     this.useCustomerMe = (...args) => this._customer.useCustomerMe(...args);
@@ -727,6 +1147,7 @@ var QueryHooks = class extends CollectionHooks {
     this.setCustomerData = (data) => this._customer.setCustomerData(data);
     this._customer = new CustomerHooks(queryClient, customerAuth);
     this._commerce = commerceClient;
+    this.market = normalizeMarket(market);
   }
   ensureCommerce() {
     if (!this._commerce) {
@@ -736,8 +1157,11 @@ var QueryHooks = class extends CollectionHooks {
     }
     return this._commerce;
   }
+  withProductMarket(params) {
+    return withDefaultMarket(params, this.market);
+  }
   useProductListingGroupsQuery(params, options) {
-    const queryOptions = params.options;
+    const queryOptions = this.withProductMarket(params.options);
     const { placeholderData, ...restOptions } = options ?? {};
     return useQueryOriginal3({
       queryKey: productKeys.listingGroups(queryOptions),
@@ -749,7 +1173,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useProductListingGroupsCatalogQuery(params, options) {
-    const queryOptions = params.options;
+    const queryOptions = this.withProductMarket(params.options);
     const { placeholderData, ...restOptions } = options ?? {};
     return useQueryOriginal3({
       queryKey: productKeys.listingGroupsCatalog(queryOptions),
@@ -764,7 +1188,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useSuspenseProductListingGroupsQuery(params, options) {
-    const queryOptions = params.options;
+    const queryOptions = this.withProductMarket(params.options);
     return useSuspenseQueryOriginal2({
       queryKey: productKeys.listingGroups(queryOptions),
       queryFn: async () => fetchProductListingGroupsQuery(this.collectionClient, queryOptions),
@@ -772,7 +1196,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useSuspenseProductListingGroupsCatalogQuery(params, options) {
-    const queryOptions = params.options;
+    const queryOptions = this.withProductMarket(params.options);
     return useSuspenseQueryOriginal2({
       queryKey: productKeys.listingGroupsCatalog(queryOptions),
       queryFn: async () => fetchProductListingGroupsCatalogQuery(
@@ -783,7 +1207,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useInfiniteProductListingGroupsQuery(params, options) {
-    const { options: queryOptions } = params;
+    const queryOptions = this.withProductMarket(params.options);
     const explicitPageSize = params.pageSize;
     const pageSize = explicitPageSize ?? 20;
     return useInfiniteQueryOriginal2({
@@ -802,7 +1226,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useInfiniteProductListingGroupsCatalogQuery(params, options) {
-    const { options: queryOptions } = params;
+    const queryOptions = this.withProductMarket(params.options);
     const explicitPageSize = params.pageSize;
     const pageSize = explicitPageSize ?? 20;
     return useInfiniteQueryOriginal2({
@@ -821,7 +1245,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useSuspenseInfiniteProductListingGroupsQuery(params, options) {
-    const { options: queryOptions } = params;
+    const queryOptions = this.withProductMarket(params.options);
     const explicitPageSize = params.pageSize;
     const pageSize = explicitPageSize ?? 20;
     return useSuspenseInfiniteQueryOriginal2({
@@ -840,7 +1264,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useSuspenseInfiniteProductListingGroupsCatalogQuery(params, options) {
-    const { options: queryOptions } = params;
+    const queryOptions = this.withProductMarket(params.options);
     const explicitPageSize = params.pageSize;
     const pageSize = explicitPageSize ?? 20;
     return useSuspenseInfiniteQueryOriginal2({
@@ -859,7 +1283,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   async prefetchProductListingGroupsQuery(params, options) {
-    const queryOptions = params.options;
+    const queryOptions = this.withProductMarket(params.options);
     return this.queryClient.prefetchQuery({
       queryKey: productKeys.listingGroups(queryOptions),
       queryFn: async () => fetchProductListingGroupsQuery(this.collectionClient, queryOptions),
@@ -867,7 +1291,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   async prefetchProductListingGroupsCatalogQuery(params, options) {
-    const queryOptions = params.options;
+    const queryOptions = this.withProductMarket(params.options);
     return this.queryClient.prefetchQuery({
       queryKey: productKeys.listingGroupsCatalog(queryOptions),
       queryFn: async () => fetchProductListingGroupsCatalogQuery(
@@ -878,7 +1302,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   async prefetchInfiniteProductListingGroupsQuery(params, options) {
-    const { options: queryOptions } = params;
+    const queryOptions = this.withProductMarket(params.options);
     const explicitPageSize = params.pageSize;
     const pageSize = explicitPageSize ?? 20;
     return this.queryClient.prefetchInfiniteQuery({
@@ -898,7 +1322,7 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   async prefetchInfiniteProductListingGroupsCatalogQuery(params, options) {
-    const { options: queryOptions } = params;
+    const queryOptions = this.withProductMarket(params.options);
     const explicitPageSize = params.pageSize;
     const pageSize = explicitPageSize ?? 20;
     return this.queryClient.prefetchInfiniteQuery({
@@ -920,7 +1344,9 @@ var QueryHooks = class extends CollectionHooks {
   useProductListingPage(params = {}, options) {
     const { placeholderData, ...restOptions } = options ?? {};
     return useQueryOriginal3({
-      ...productListingPageQueryOptions(this.ensureCommerce(), params),
+      ...productListingPageQueryOptions(this.ensureCommerce(), params, {
+        market: this.market
+      }),
       ...restOptions,
       ...placeholderData !== void 0 && {
         placeholderData
@@ -930,13 +1356,17 @@ var QueryHooks = class extends CollectionHooks {
   useSuspenseProductListingPage(params = {}, options) {
     const suspenseOptions = options;
     return useSuspenseQueryOriginal2({
-      ...productListingPageQueryOptions(this.ensureCommerce(), params),
+      ...productListingPageQueryOptions(this.ensureCommerce(), params, {
+        market: this.market
+      }),
       ...suspenseOptions
     });
   }
   useInfiniteProductListingPage(params = {}, options) {
     return useInfiniteQueryOriginal2({
-      ...productListingPageInfiniteQueryOptions(this.ensureCommerce(), params),
+      ...productListingPageInfiniteQueryOptions(this.ensureCommerce(), params, {
+        market: this.market
+      }),
       ...options
     });
   }
@@ -945,7 +1375,8 @@ var QueryHooks = class extends CollectionHooks {
       this.queryClient,
       this.ensureCommerce(),
       params,
-      options
+      options,
+      { market: this.market }
     );
   }
   async prefetchInfiniteProductListingPage(params = {}, options) {
@@ -953,25 +1384,45 @@ var QueryHooks = class extends CollectionHooks {
       this.queryClient,
       this.ensureCommerce(),
       params,
-      options
+      options,
+      { market: this.market }
     );
   }
   useProductDetail(params, options) {
     const discriminator = "slug" in params ? params.slug : params.id;
     const { enabled, ...restOptions } = options ?? {};
     const queryEnabled = enabled !== false && Boolean(discriminator);
+    const effectiveParams = this.withProductMarket(params) ?? params;
     return useQueryOriginal3({
-      queryKey: productKeys.detail(params),
-      queryFn: () => this._commerce.product.detail(params),
+      queryKey: productKeys.detail(effectiveParams),
+      queryFn: () => this._commerce.product.detail(effectiveParams),
       enabled: queryEnabled,
       ...restOptions
     });
   }
   useProductDetailBySlug(slug, options) {
-    return this.useProductDetail({ slug }, options);
+    const { market, locale, fallbackLocale, ...queryOptions } = options ?? {};
+    return this.useProductDetail(
+      {
+        slug,
+        ...market ? { market } : {},
+        ...locale ? { locale } : {},
+        ...fallbackLocale !== void 0 ? { fallbackLocale } : {}
+      },
+      queryOptions
+    );
   }
   useProductDetailById(id, options) {
-    return this.useProductDetail({ id }, options);
+    const { market, locale, fallbackLocale, ...queryOptions } = options ?? {};
+    return this.useProductDetail(
+      {
+        id,
+        ...market ? { market } : {},
+        ...locale ? { locale } : {},
+        ...fallbackLocale !== void 0 ? { fallbackLocale } : {}
+      },
+      queryOptions
+    );
   }
 };
 
@@ -1121,6 +1572,9 @@ var RealtimeConnection = class {
 };
 
 // src/core/query/query-client.ts
+function getClientMarket(client) {
+  return client.getConfig?.().market;
+}
 function createReadOnlyQueryHooksFacade(hooks) {
   return {
     useQuery: hooks.useQuery.bind(hooks),
@@ -1168,7 +1622,8 @@ function createQueryHooks(client, queryClient = getQueryClient()) {
     queryClient,
     client.collections,
     client.customer.auth,
-    client.commerce
+    client.commerce,
+    getClientMarket(client)
   );
   return createReadOnlyQueryHooksFacade(hooks);
 }
@@ -1177,7 +1632,8 @@ function createServerQueryHooks(client, queryClient = getQueryClient()) {
     queryClient,
     client.collections,
     void 0,
-    client.commerce
+    client.commerce,
+    getClientMarket(client)
   );
 }
 export {
@@ -1185,6 +1641,7 @@ export {
   CustomerHooks,
   QueryHooks,
   RealtimeConnection,
+  canonicalProductListingGroupsQueryOptions,
   collectionKeys,
   createQueryHooks,
   createServerQueryHooks,