@01.software/sdk 0.37.0 → 0.39.0

package/dist/query.cjs

@@ -30,7 +30,11 @@ __export(query_exports, {
   customerKeys: () => customerKeys,
   getQueryClient: () => getQueryClient,
   getStorefrontQueryClient: () => getStorefrontQueryClient,
-  productKeys: () => productKeys
+  prefetchInfiniteProductListingPage: () => prefetchInfiniteProductListingPage,
+  prefetchProductListingPage: () => prefetchProductListingPage,
+  productKeys: () => productKeys,
+  productListingPageInfiniteQueryOptions: () => productListingPageInfiniteQueryOptions,
+  productListingPageQueryOptions: () => productListingPageQueryOptions
 });
 module.exports = __toCommonJS(query_exports);
 
@@ -90,6 +94,49 @@ function getStorefrontQueryClient() {
 }
 
 // src/core/query/query-keys.ts
+function nonEmpty(values) {
+  return values?.length ? values : void 0;
+}
+function canonicalProductListingPageParams(params = {}, limit) {
+  const filters = params.filters;
+  const canonicalFilters = {};
+  const ids = nonEmpty(filters?.ids);
+  if (ids) canonicalFilters.ids = ids;
+  const slugs = nonEmpty(filters?.slugs);
+  if (slugs) canonicalFilters.slugs = slugs;
+  const handles = nonEmpty(filters?.handles);
+  if (handles) canonicalFilters.handles = handles;
+  const categoryIds = nonEmpty(filters?.categoryIds);
+  if (categoryIds) canonicalFilters.categoryIds = categoryIds;
+  const tagIds = nonEmpty(filters?.tagIds);
+  if (tagIds) canonicalFilters.tagIds = tagIds;
+  if (filters?.price?.min != null || filters?.price?.max != null) {
+    canonicalFilters.price = {
+      ...filters.price.min != null && { min: filters.price.min },
+      ...filters.price.max != null && { max: filters.price.max }
+    };
+  }
+  if (filters?.availableForSale != null) {
+    canonicalFilters.availableForSale = filters.availableForSale;
+  }
+  const search = params.search?.trim();
+  return {
+    mode: params.mode ?? "catalog",
+    ...params.page != null && { page: params.page },
+    ...limit != null ? { limit } : params.limit != null ? { limit: params.limit } : {},
+    ...search && { search },
+    ...params.sort != null && { sort: params.sort },
+    ...Object.keys(canonicalFilters).length > 0 && {
+      filters: canonicalFilters
+    },
+    ...params.basePath != null && { basePath: params.basePath },
+    ...params.trailingSlash != null && { trailingSlash: params.trailingSlash },
+    ...params.emit != null && { emit: params.emit },
+    ...params.preferCompleteVariantFromHint != null && {
+      preferCompleteVariantFromHint: params.preferCompleteVariantFromHint
+    }
+  };
+}
 function collectionKeys(collection) {
   return {
     all: [collection],
@@ -98,7 +145,11 @@ function collectionKeys(collection) {
     details: () => [collection, "detail"],
     detail: (id, options) => [collection, "detail", id, options],
     infinites: () => [collection, "infinite"],
-    infinite: (options) => [collection, "infinite", options]
+    infinite: (options, pageSize) => [
+      collection,
+      "infinite",
+      pageSize === void 0 ? options : { ...options, limit: pageSize }
+    ]
   };
 }
 var customerKeys = {
@@ -108,8 +159,29 @@ var customerKeys = {
 var productKeys = {
   listingGroups: (options) => ["products", "listing-groups", "list", options],
   listingGroupsCatalog: (options) => ["products", "listing-groups", "catalog", options],
-  listingGroupsInfinite: (options) => ["products", "listing-groups", "infinite", options],
-  listingGroupsCatalogInfinite: (options) => ["products", "listing-groups", "catalog", "infinite", options],
+  listingGroupsInfinite: (options, pageSize) => [
+    "products",
+    "listing-groups",
+    "infinite",
+    pageSize === void 0 ? options : { ...options, limit: pageSize }
+  ],
+  listingGroupsCatalogInfinite: (options, pageSize) => [
+    "products",
+    "listing-groups",
+    "catalog",
+    "infinite",
+    pageSize === void 0 ? options : { ...options, limit: pageSize }
+  ],
+  listingPage: (params) => ["products", "listing-page", canonicalProductListingPageParams(params)],
+  listingPageInfinite: (params, pageSize) => [
+    "products",
+    "listing-page",
+    "infinite",
+    canonicalProductListingPageParams(
+      params,
+      pageSize
+    )
+  ],
   detail: (params) => ["products", "detail", params],
   detailAll: () => ["products", "detail"]
 };
@@ -190,13 +262,14 @@ var CollectionHooks = class {
   }
   // ===== useInfiniteQuery =====
   useInfiniteQuery(params, options) {
-    const {
-      collection,
-      options: queryOptions,
-      pageSize = DEFAULT_PAGE_SIZE
-    } = params;
+    const { collection, options: queryOptions } = params;
+    const explicitPageSize = params.pageSize;
+    const pageSize = explicitPageSize ?? DEFAULT_PAGE_SIZE;
     return (0, import_react_query2.useInfiniteQuery)({
-      queryKey: collectionKeys(collection).infinite(queryOptions),
+      queryKey: collectionKeys(collection).infinite(
+        queryOptions,
+        explicitPageSize
+      ),
       queryFn: async ({ pageParam }) => {
         const response = await this.collectionClient.from(collection).find({ ...queryOptions, page: pageParam, limit: pageSize });
         return response;
@@ -210,13 +283,14 @@ var CollectionHooks = class {
   }
   // ===== useSuspenseInfiniteQuery =====
   useSuspenseInfiniteQuery(params, options) {
-    const {
-      collection,
-      options: queryOptions,
-      pageSize = DEFAULT_PAGE_SIZE
-    } = params;
+    const { collection, options: queryOptions } = params;
+    const explicitPageSize = params.pageSize;
+    const pageSize = explicitPageSize ?? DEFAULT_PAGE_SIZE;
     return (0, import_react_query2.useSuspenseInfiniteQuery)({
-      queryKey: collectionKeys(collection).infinite(queryOptions),
+      queryKey: collectionKeys(collection).infinite(
+        queryOptions,
+        explicitPageSize
+      ),
       queryFn: async ({ pageParam }) => {
         const response = await this.collectionClient.from(collection).find({ ...queryOptions, page: pageParam, limit: pageSize });
         return response;
@@ -252,13 +326,14 @@ var CollectionHooks = class {
   }
   // ===== prefetchInfiniteQuery =====
   async prefetchInfiniteQuery(params, options) {
-    const {
-      collection,
-      options: queryOptions,
-      pageSize = DEFAULT_PAGE_SIZE
-    } = params;
+    const { collection, options: queryOptions } = params;
+    const explicitPageSize = params.pageSize;
+    const pageSize = explicitPageSize ?? DEFAULT_PAGE_SIZE;
     return this.queryClient.prefetchInfiniteQuery({
-      queryKey: collectionKeys(collection).infinite(queryOptions),
+      queryKey: collectionKeys(collection).infinite(
+        queryOptions,
+        explicitPageSize
+      ),
       queryFn: async ({ pageParam }) => {
         const response = await this.collectionClient.from(collection).find({ ...queryOptions, page: pageParam, limit: pageSize });
         return response;
@@ -400,115 +475,13 @@ var SDKError = class extends Error {
     };
   }
 };
-var NetworkError = class extends SDKError {
-  constructor(message, status, details, userMessage, suggestion) {
-    super("NETWORK_ERROR", message, status, details, userMessage, suggestion);
-    this.name = "NetworkError";
-  }
-};
-var ValidationError = class extends SDKError {
-  constructor(message, details, userMessage, suggestion, status = 400) {
-    super("VALIDATION_ERROR", message, status, details, userMessage, suggestion);
-    this.name = "ValidationError";
-  }
-};
-var ApiError = class extends SDKError {
-  constructor(message, status, details, userMessage, suggestion, requestId) {
-    super(
-      "API_ERROR",
-      message,
-      status,
-      details,
-      userMessage,
-      suggestion,
-      requestId
-    );
-    this.name = "ApiError";
-  }
-};
 var ConfigError = class extends SDKError {
   constructor(message, details, userMessage, suggestion) {
     super("CONFIG_ERROR", message, void 0, details, userMessage, suggestion);
     this.name = "ConfigError";
   }
 };
-var TimeoutError = class extends SDKError {
-  constructor(message = "Request timed out.", details, userMessage, suggestion) {
-    super("TIMEOUT_ERROR", message, 408, details, userMessage, suggestion);
-    this.name = "TimeoutError";
-  }
-};
-var UsageLimitError = class extends SDKError {
-  constructor(message, usage, details, userMessage, suggestion) {
-    super("USAGE_LIMIT_ERROR", message, 429, details, userMessage, suggestion);
-    this.name = "UsageLimitError";
-    this.usage = usage;
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      usage: this.usage
-    };
-  }
-};
-var AuthError = class extends SDKError {
-  constructor(message, details, userMessage, suggestion, requestId) {
-    super(
-      "auth_error",
-      message,
-      401,
-      details,
-      userMessage,
-      suggestion,
-      requestId
-    );
-    this.name = "AuthError";
-  }
-};
-var PermissionError = class extends SDKError {
-  constructor(message, details, userMessage, suggestion, requestId) {
-    super(
-      "permission_error",
-      message,
-      403,
-      details,
-      userMessage,
-      suggestion,
-      requestId
-    );
-    this.name = "PermissionError";
-  }
-};
-var NotFoundError = class extends SDKError {
-  constructor(message, details, userMessage, suggestion, requestId) {
-    super(
-      "not_found",
-      message,
-      404,
-      details,
-      userMessage,
-      suggestion,
-      requestId
-    );
-    this.name = "NotFoundError";
-  }
-};
-var ConflictError = class extends SDKError {
-  constructor(message, details, userMessage, suggestion, requestId) {
-    super("conflict", message, 409, details, userMessage, suggestion, requestId);
-    this.name = "ConflictError";
-  }
-};
-var createNetworkError = (message, status, details, userMessage, suggestion) => new NetworkError(message, status, details, userMessage, suggestion);
-var createValidationError = (message, details, userMessage, suggestion, status) => new ValidationError(message, details, userMessage, suggestion, status);
-var createApiError = (message, status, details, userMessage, suggestion, requestId) => new ApiError(message, status, details, userMessage, suggestion, requestId);
 var createConfigError = (message, details, userMessage, suggestion) => new ConfigError(message, details, userMessage, suggestion);
-var createTimeoutError = (message, details, userMessage, suggestion) => new TimeoutError(message, details, userMessage, suggestion);
-var createUsageLimitError = (message, usage, details, userMessage, suggestion) => new UsageLimitError(message, usage, details, userMessage, suggestion);
-var createAuthError = (message, details, userMessage, suggestion, requestId) => new AuthError(message, details, userMessage, suggestion, requestId);
-var createPermissionError = (message, details, userMessage, suggestion, requestId) => new PermissionError(message, details, userMessage, suggestion, requestId);
-var createNotFoundError = (message, details, userMessage, suggestion, requestId) => new NotFoundError(message, details, userMessage, suggestion, requestId);
-var createConflictError = (message, details, userMessage, suggestion, requestId) => new ConflictError(message, details, userMessage, suggestion, requestId);
 
 // src/core/query/customer-hooks.ts
 function createMutation(mutationFn, callbacks, onSuccessExtra) {
@@ -661,6 +634,50 @@ function fetchProductListingGroupsCatalogQuery(collectionClient, queryOptions) {
     listingGroupsQueryCatalogUrl(queryOptions)
   );
 }
+function productListingPageQueryOptions(commerceClient, params = {}) {
+  return {
+    queryKey: productKeys.listingPage(params),
+    queryFn: () => commerceClient.product.listingPage(params)
+  };
+}
+function productListingPageInfiniteQueryOptions(commerceClient, params = {}) {
+  const {
+    pageSize: explicitPageSize,
+    page: _page,
+    limit: _limit,
+    ...pageParams
+  } = params;
+  const pageSize = explicitPageSize ?? 20;
+  return {
+    queryKey: productKeys.listingPageInfinite(pageParams, explicitPageSize),
+    queryFn: ({ pageParam }) => commerceClient.product.listingPage({
+      ...pageParams,
+      page: pageParam,
+      limit: pageSize
+    }),
+    initialPageParam: 1,
+    getNextPageParam: (lastPage) => lastPage.hasNextPage ? lastPage.nextPage : void 0
+  };
+}
+function prefetchProductListingPage(queryClient, commerceClient, params = {}, options) {
+  return queryClient.prefetchQuery({
+    ...productListingPageQueryOptions(
+      commerceClient,
+      params
+    ),
+    ...options
+  });
+}
+function prefetchInfiniteProductListingPage(queryClient, commerceClient, params = {}, options) {
+  return queryClient.prefetchInfiniteQuery({
+    ...productListingPageInfiniteQueryOptions(
+      commerceClient,
+      params
+    ),
+    pages: options?.pages ?? 1,
+    staleTime: options?.staleTime
+  });
+}
 var QueryHooks = class extends CollectionHooks {
   constructor(queryClient, collectionClient, customerAuth, commerceClient) {
     super(queryClient, collectionClient);
@@ -681,6 +698,14 @@ var QueryHooks = class extends CollectionHooks {
     this._customer = new CustomerHooks(queryClient, customerAuth);
     this._commerce = commerceClient;
   }
+  ensureCommerce() {
+    if (!this._commerce) {
+      throw createConfigError(
+        "Product listing page hooks require Client or ServerClient. Use createQueryHooks(client) or createServerQueryHooks(server) instead of constructing QueryHooks directly."
+      );
+    }
+    return this._commerce;
+  }
   useProductListingGroupsQuery(params, options) {
     const queryOptions = params.options;
     const { placeholderData, ...restOptions } = options ?? {};
@@ -728,12 +753,14 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useInfiniteProductListingGroupsQuery(params, options) {
-    const {
-      options: queryOptions,
-      pageSize = 20
-    } = params;
+    const { options: queryOptions } = params;
+    const explicitPageSize = params.pageSize;
+    const pageSize = explicitPageSize ?? 20;
     return (0, import_react_query4.useInfiniteQuery)({
-      queryKey: productKeys.listingGroupsInfinite(queryOptions),
+      queryKey: productKeys.listingGroupsInfinite(
+        queryOptions,
+        explicitPageSize
+      ),
       queryFn: async ({ pageParam }) => fetchProductListingGroupsQuery(this.collectionClient, {
         ...queryOptions,
         page: pageParam,
@@ -745,12 +772,14 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useInfiniteProductListingGroupsCatalogQuery(params, options) {
-    const {
-      options: queryOptions,
-      pageSize = 20
-    } = params;
+    const { options: queryOptions } = params;
+    const explicitPageSize = params.pageSize;
+    const pageSize = explicitPageSize ?? 20;
     return (0, import_react_query4.useInfiniteQuery)({
-      queryKey: productKeys.listingGroupsCatalogInfinite(queryOptions),
+      queryKey: productKeys.listingGroupsCatalogInfinite(
+        queryOptions,
+        explicitPageSize
+      ),
       queryFn: async ({ pageParam }) => fetchProductListingGroupsCatalogQuery(this.collectionClient, {
         ...queryOptions,
         page: pageParam,
@@ -762,12 +791,14 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useSuspenseInfiniteProductListingGroupsQuery(params, options) {
-    const {
-      options: queryOptions,
-      pageSize = 20
-    } = params;
+    const { options: queryOptions } = params;
+    const explicitPageSize = params.pageSize;
+    const pageSize = explicitPageSize ?? 20;
     return (0, import_react_query4.useSuspenseInfiniteQuery)({
-      queryKey: productKeys.listingGroupsInfinite(queryOptions),
+      queryKey: productKeys.listingGroupsInfinite(
+        queryOptions,
+        explicitPageSize
+      ),
       queryFn: async ({ pageParam }) => fetchProductListingGroupsQuery(this.collectionClient, {
         ...queryOptions,
         page: pageParam,
@@ -779,12 +810,14 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   useSuspenseInfiniteProductListingGroupsCatalogQuery(params, options) {
-    const {
-      options: queryOptions,
-      pageSize = 20
-    } = params;
+    const { options: queryOptions } = params;
+    const explicitPageSize = params.pageSize;
+    const pageSize = explicitPageSize ?? 20;
     return (0, import_react_query4.useSuspenseInfiniteQuery)({
-      queryKey: productKeys.listingGroupsCatalogInfinite(queryOptions),
+      queryKey: productKeys.listingGroupsCatalogInfinite(
+        queryOptions,
+        explicitPageSize
+      ),
       queryFn: async ({ pageParam }) => fetchProductListingGroupsCatalogQuery(this.collectionClient, {
         ...queryOptions,
         page: pageParam,
@@ -815,12 +848,14 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   async prefetchInfiniteProductListingGroupsQuery(params, options) {
-    const {
-      options: queryOptions,
-      pageSize = 20
-    } = params;
+    const { options: queryOptions } = params;
+    const explicitPageSize = params.pageSize;
+    const pageSize = explicitPageSize ?? 20;
     return this.queryClient.prefetchInfiniteQuery({
-      queryKey: productKeys.listingGroupsInfinite(queryOptions),
+      queryKey: productKeys.listingGroupsInfinite(
+        queryOptions,
+        explicitPageSize
+      ),
       queryFn: async ({ pageParam }) => fetchProductListingGroupsQuery(this.collectionClient, {
         ...queryOptions,
         page: pageParam,
@@ -833,12 +868,14 @@ var QueryHooks = class extends CollectionHooks {
     });
   }
   async prefetchInfiniteProductListingGroupsCatalogQuery(params, options) {
-    const {
-      options: queryOptions,
-      pageSize = 20
-    } = params;
+    const { options: queryOptions } = params;
+    const explicitPageSize = params.pageSize;
+    const pageSize = explicitPageSize ?? 20;
     return this.queryClient.prefetchInfiniteQuery({
-      queryKey: productKeys.listingGroupsCatalogInfinite(queryOptions),
+      queryKey: productKeys.listingGroupsCatalogInfinite(
+        queryOptions,
+        explicitPageSize
+      ),
       queryFn: async ({ pageParam }) => fetchProductListingGroupsCatalogQuery(this.collectionClient, {
         ...queryOptions,
         page: pageParam,
@@ -850,6 +887,45 @@ var QueryHooks = class extends CollectionHooks {
       staleTime: options?.staleTime
     });
   }
+  useProductListingPage(params = {}, options) {
+    const { placeholderData, ...restOptions } = options ?? {};
+    return (0, import_react_query4.useQuery)({
+      ...productListingPageQueryOptions(this.ensureCommerce(), params),
+      ...restOptions,
+      ...placeholderData !== void 0 && {
+        placeholderData
+      }
+    });
+  }
+  useSuspenseProductListingPage(params = {}, options) {
+    const suspenseOptions = options;
+    return (0, import_react_query4.useSuspenseQuery)({
+      ...productListingPageQueryOptions(this.ensureCommerce(), params),
+      ...suspenseOptions
+    });
+  }
+  useInfiniteProductListingPage(params = {}, options) {
+    return (0, import_react_query4.useInfiniteQuery)({
+      ...productListingPageInfiniteQueryOptions(this.ensureCommerce(), params),
+      ...options
+    });
+  }
+  async prefetchProductListingPage(params = {}, options) {
+    return prefetchProductListingPage(
+      this.queryClient,
+      this.ensureCommerce(),
+      params,
+      options
+    );
+  }
+  async prefetchInfiniteProductListingPage(params = {}, options) {
+    return prefetchInfiniteProductListingPage(
+      this.queryClient,
+      this.ensureCommerce(),
+      params,
+      options
+    );
+  }
   useProductDetail(params, options) {
     const discriminator = "slug" in params ? params.slug : params.id;
     const { enabled, ...restOptions } = options ?? {};
@@ -1001,7 +1077,7 @@ var RealtimeConnection = class {
   }
   scheduleReconnect() {
     if (this.reconnectTimer) return;
-    const delay2 = Math.min(
+    const delay = Math.min(
       INITIAL_RECONNECT_DELAY * Math.pow(RECONNECT_BACKOFF_FACTOR, this.reconnectAttempt),
       MAX_RECONNECT_DELAY
     );
@@ -1010,918 +1086,7 @@ var RealtimeConnection = class {
       this.reconnectTimer = null;
       this.abortController = new AbortController();
       this.startStream(this.abortController.signal);
-    }, delay2);
-  }
-};
-
-// src/utils/types.ts
-function resolveRelation(ref) {
-  if (typeof ref === "string" || typeof ref === "number" || ref === null || ref === void 0)
-    return null;
-  return ref;
-}
-
-// src/core/metadata/index.ts
-var OPEN_GRAPH_IMAGE_SIZE = "1200";
-var LEGACY_OPEN_GRAPH_IMAGE_SIZE = "1536";
-function extractSeo(doc) {
-  const seo = doc.seo ?? {};
-  const og = seo.openGraph ?? {};
-  return {
-    title: seo.title ?? doc.title ?? null,
-    description: seo.description ?? null,
-    noIndex: seo.noIndex ?? null,
-    canonical: seo.canonical ?? null,
-    openGraph: {
-      title: og.title ?? null,
-      description: og.description ?? null,
-      image: og.image ?? null
-    }
-  };
-}
-function generateMetadata(input, options) {
-  const title = input.title ?? void 0;
-  const description = input.description ?? void 0;
-  const ogTitle = input.openGraph?.title ?? title;
-  const ogDescription = input.openGraph?.description ?? description;
-  const image = resolveMetaImage(input.openGraph?.image);
-  return {
-    title,
-    description,
-    ...input.noIndex && { robots: { index: false, follow: false } },
-    ...input.canonical && { alternates: { canonical: input.canonical } },
-    openGraph: {
-      ...ogTitle && { title: ogTitle },
-      ...ogDescription && { description: ogDescription },
-      ...options?.siteName && { siteName: options.siteName },
-      ...image && { images: [image] }
-    },
-    twitter: {
-      card: image ? "summary_large_image" : "summary",
-      ...ogTitle && { title: ogTitle },
-      ...ogDescription && { description: ogDescription },
-      ...image && { images: [image.url] }
-    }
-  };
-}
-function resolveMetaImage(ref) {
-  const image = resolveRelation(ref);
-  if (!image) return null;
-  const sized = image.sizes?.[OPEN_GRAPH_IMAGE_SIZE] ?? image.sizes?.[LEGACY_OPEN_GRAPH_IMAGE_SIZE];
-  const url = sized?.url || image.url;
-  if (!url) return null;
-  const width = sized?.url ? sized.width : image.width;
-  const height = sized?.url ? sized.height : image.height;
-  return {
-    url,
-    ...width && { width },
-    ...height && { height },
-    ...image.alt && { alt: image.alt }
-  };
-}
-
-// src/core/collection/query-builder.ts
-var CollectionQueryBuilder = class {
-  constructor(api, collection) {
-    this.api = api;
-    this.collection = collection;
-  }
-  /**
-   * Find documents (list query)
-   * GET /api/{collection}
-   * @returns Payload CMS find response with docs array and pagination
-   */
-  async find(options) {
-    return this.api.requestFind(
-      `/api/${String(this.collection)}`,
-      options
-    );
-  }
-  /**
-   * Find document by ID
-   * GET /api/{collection}/{id}
-   * @returns Document object directly (no wrapper)
-   */
-  async findById(id, options) {
-    return this.api.requestFindById(
-      `/api/${String(this.collection)}/${String(id)}`,
-      options
-    );
-  }
-  /**
-   * Create a new document
-   * POST /api/{collection}
-   * @returns Payload CMS mutation response with doc and message
-   */
-  async create(data, options) {
-    const endpoint = `/api/${String(this.collection)}`;
-    if (options?.file) {
-      return this.api.requestCreateWithFile(
-        endpoint,
-        data,
-        options.file,
-        options.filename
-      );
-    }
-    return this.api.requestCreate(endpoint, data);
-  }
-  /**
-   * Update a document by ID
-   * PATCH /api/{collection}/{id}
-   * @returns Payload CMS mutation response with doc and message
-   */
-  async update(id, data, options) {
-    const endpoint = `/api/${String(this.collection)}/${String(id)}`;
-    if (options?.file) {
-      return this.api.requestUpdateWithFile(
-        endpoint,
-        data,
-        options.file,
-        options.filename
-      );
-    }
-    return this.api.requestUpdate(endpoint, data);
-  }
-  /**
-   * Count documents
-   * GET /api/{collection}/count
-   * @returns Count response with totalDocs
-   */
-  async count(options) {
-    return this.api.requestCount(
-      `/api/${String(this.collection)}/count`,
-      options
-    );
-  }
-  /**
-   * Find first matching document and return its Next.js Metadata.
-   * Applies depth: 1 (SEO image populate) and limit: 1 automatically.
-   * @returns Metadata or null if no document matches
-   */
-  async findMetadata(options, metadataOptions) {
-    const { docs } = await this.find({ ...options, limit: 1, depth: 1 });
-    const doc = docs[0];
-    if (!doc) return null;
-    return generateMetadata(
-      extractSeo(doc),
-      metadataOptions
-    );
-  }
-  /**
-   * Find document by ID and return its Next.js Metadata.
-   * Applies depth: 1 (SEO image populate) automatically.
-   * @returns Metadata (throws on 404)
-   */
-  async findMetadataById(id, metadataOptions) {
-    const doc = await this.findById(id, { depth: 1 });
-    return generateMetadata(
-      extractSeo(doc),
-      metadataOptions
-    );
-  }
-  /**
-   * Update multiple documents (bulk update)
-   * PATCH /api/{collection}
-   * @returns Payload CMS find response with updated docs
-   */
-  async updateMany(where, data) {
-    return this.api.requestUpdateMany(
-      `/api/${String(this.collection)}`,
-      { where, data }
-    );
-  }
-  /**
-   * Delete a document by ID
-   * DELETE /api/{collection}/{id}
-   * @returns Deleted document object directly (no wrapper)
-   */
-  async remove(id) {
-    return this.api.requestDelete(
-      `/api/${String(this.collection)}/${String(id)}`
-    );
-  }
-  /**
-   * Delete multiple documents (bulk delete)
-   * DELETE /api/{collection}
-   * @returns Payload CMS find response with deleted docs
-   */
-  async removeMany(where) {
-    return this.api.requestDeleteMany(
-      `/api/${String(this.collection)}`,
-      { where }
-    );
-  }
-};
-
-// src/core/collection/http-client.ts
-var import_qs_esm = require("qs-esm");
-
-// src/core/internal/utils/credentials.ts
-function requirePublishableKeyForSecret(apiName, publishableKey, secretKey) {
-  if (secretKey && !publishableKey) {
-    throw createConfigError(
-      `publishableKey is required for ${apiName} when secretKey is used. It is sent as X-Publishable-Key for tenant routing, rate limiting, and quota enforcement.`
-    );
-  }
-  return publishableKey ?? "";
-}
-
-// src/core/client/types.ts
-function resolveApiUrl(apiUrl) {
-  if (apiUrl) {
-    return apiUrl.replace(/\/$/, "");
-  }
-  if (typeof process !== "undefined" && process.env) {
-    const envUrl = process.env.SOFTWARE_API_URL || process.env.NEXT_PUBLIC_SOFTWARE_API_URL;
-    if (envUrl) {
-      return envUrl.replace(/\/$/, "");
-    }
-  }
-  return "https://api.01.software";
-}
-
-// src/core/internal/utils/http.ts
-var DEFAULT_TIMEOUT = 3e4;
-var STOREFRONT_BROWSER_TIMEOUT = 15e3;
-var DEFAULT_RETRYABLE_STATUSES = [408, 429, 500, 502, 503, 504];
-var NON_RETRYABLE_STATUSES = [400, 401, 403, 404, 409, 422];
-var SAFE_METHODS = ["GET", "HEAD", "OPTIONS"];
-var DEFAULT_MAX_RETRIES = 3;
-var STOREFRONT_BROWSER_MAX_RETRIES = 1;
-function debugLog(debug, type, message, data) {
-  if (!debug) return;
-  const shouldLog = debug === true || type === "request" && debug.logRequests || type === "response" && debug.logResponses || type === "error" && debug.logErrors;
-  if (shouldLog) {
-    console.group(`[SDK ${type.toUpperCase()}] ${message}`);
-    if (data) console.log(data);
-    console.groupEnd();
-  }
-}
-function redactSensitiveHeader(value) {
-  const prefix = value.toLowerCase().startsWith("bearer ") ? "Bearer " : "";
-  return value.length > 20 ? `${prefix}...****${value.slice(-8)}` : "****";
-}
-function redactSensitiveHeaders(headers) {
-  const redacted = Object.fromEntries(headers.entries());
-  if (redacted.authorization) {
-    redacted.authorization = redactSensitiveHeader(redacted.authorization);
-  }
-  if (redacted["x-preview-token"]) {
-    redacted["x-preview-token"] = redactSensitiveHeader(
-      redacted["x-preview-token"]
-    );
-  }
-  return redacted;
-}
-function getErrorSuggestion(status) {
-  if (status === 400)
-    return "The request data failed validation. Check field values and types.";
-  if (status === 401) return "Please check your authentication credentials.";
-  if (status === 403)
-    return "Access denied. Check your credentials or permissions.";
-  if (status === 404) return "The requested resource was not found.";
-  if (status === 422) return "The request data failed validation.";
-  if (status >= 500) return "A server error occurred. Please try again later.";
-  return void 0;
-}
-function isUsageLimitExceededResponse(response) {
-  if (response.status !== 429) return false;
-  const limit = parseInt(response.headers.get("X-Usage-Limit") || "", 10);
-  const current = parseInt(response.headers.get("X-Usage-Current") || "", 10);
-  if (!Number.isFinite(limit) || !Number.isFinite(current)) return false;
-  return response.headers.get("X-Usage-Exceeded") === "true" || current > limit;
-}
-async function parseErrorBody(response) {
-  const fallback = {
-    errorMessage: `HTTP ${response.status}: ${response.statusText}`,
-    userMessage: `Request failed (status: ${response.status})`
-  };
-  try {
-    const body = await response.json();
-    const reason = typeof body.reason === "string" ? body.reason : typeof body.code === "string" ? body.code : void 0;
-    if (body.errors && Array.isArray(body.errors)) {
-      const fieldErrors = [];
-      for (const e of body.errors) {
-        if (e.data?.errors && Array.isArray(e.data.errors) && e.data.errors.length > 0) {
-          for (const fe of e.data.errors) {
-            fieldErrors.push({
-              field: fe.path || fe.field,
-              message: fe.message
-            });
-          }
-        } else if (e.field || e.message) {
-          fieldErrors.push({ field: e.field, message: e.message });
-        }
-      }
-      const details = (fieldErrors.length > 0 ? fieldErrors : body.errors).map(
-        (e) => e.field ? `${e.field}: ${e.message}` : e.message
-      ).filter(Boolean).join("; ");
-      if (details) {
-        return {
-          errorMessage: `HTTP ${response.status}: ${details}`,
-          userMessage: details,
-          reason,
-          body,
-          errors: fieldErrors.length > 0 ? fieldErrors : body.errors
-        };
-      }
-    }
-    if (typeof body.error === "string") {
-      return {
-        errorMessage: `HTTP ${response.status}: ${body.error}`,
-        userMessage: body.error,
-        reason,
-        body
-      };
-    }
-    if (body.message) {
-      return {
-        errorMessage: `HTTP ${response.status}: ${body.message}`,
-        userMessage: body.message,
-        reason,
-        body
-      };
-    }
-    return { ...fallback, reason, body };
-  } catch {
-    return fallback;
-  }
-}
-function getParsedErrorSuggestion(status, parsed) {
-  if (status === 403 && parsed.reason === "origin_not_allowed") {
-    return "Add the request origin to the tenant Browser API origins, then retry the browser request.";
-  }
-  return getErrorSuggestion(status);
-}
-async function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function attachRequestId(err, id) {
-  if (id) err.requestId = id;
-  return err;
-}
-function createHttpStatusError(status, parsed, details, requestId) {
-  const errorDetails = {
-    ...details,
-    ...parsed.errors && { errors: parsed.errors },
-    ...parsed.body && { body: parsed.body }
-  };
-  const suggestion = getParsedErrorSuggestion(status, parsed);
-  if (status === 400 || status === 422) {
-    return attachRequestId(
-      createValidationError(
-        parsed.errorMessage,
-        errorDetails,
-        parsed.userMessage,
-        suggestion,
-        status
-      ),
-      requestId
-    );
-  }
-  if (status === 401) {
-    return attachRequestId(
-      createAuthError(
-        parsed.errorMessage,
-        errorDetails,
-        parsed.userMessage,
-        suggestion
-      ),
-      requestId
-    );
-  }
-  if (status === 403) {
-    return attachRequestId(
-      createPermissionError(
-        parsed.errorMessage,
-        errorDetails,
-        parsed.userMessage,
-        suggestion
-      ),
-      requestId
-    );
-  }
-  if (status === 404) {
-    return attachRequestId(
-      createNotFoundError(
-        parsed.errorMessage,
-        errorDetails,
-        parsed.userMessage,
-        suggestion
-      ),
-      requestId
-    );
-  }
-  if (status === 409) {
-    return attachRequestId(
-      createConflictError(
-        parsed.errorMessage,
-        errorDetails,
-        parsed.userMessage,
-        suggestion
-      ),
-      requestId
-    );
-  }
-  return attachRequestId(
-    createNetworkError(
-      parsed.errorMessage,
-      status,
-      errorDetails,
-      parsed.userMessage,
-      suggestion
-    ),
-    requestId
-  );
-}
-async function httpFetch(url, options) {
-  const {
-    apiUrl,
-    publishableKey,
-    secretKey,
-    customerToken,
-    timeout: timeoutOption = DEFAULT_TIMEOUT,
-    debug,
-    retry,
-    onUnauthorized,
-    ...requestInit
-  } = options || {};
-  const baseUrl = resolveApiUrl(apiUrl);
-  const method = (requestInit.method || "GET").toUpperCase();
-  const isPublishableKeyBrowserGet = typeof window !== "undefined" && !secretKey && !customerToken && Boolean(publishableKey) && SAFE_METHODS.includes(method);
-  const timeout = timeoutOption === DEFAULT_TIMEOUT && isPublishableKeyBrowserGet ? STOREFRONT_BROWSER_TIMEOUT : timeoutOption;
-  const retryConfig = {
-    maxRetries: retry?.maxRetries ?? (isPublishableKeyBrowserGet ? STOREFRONT_BROWSER_MAX_RETRIES : DEFAULT_MAX_RETRIES),
-    retryableStatuses: retry?.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES,
-    retryDelay: retry?.retryDelay ?? ((attempt) => Math.min(1e3 * 2 ** attempt, 1e4))
-  };
-  let authToken;
-  if (secretKey) {
-    authToken = secretKey;
-  } else if (customerToken) {
-    authToken = customerToken;
-  }
-  let lastError;
-  let hasRetried401 = false;
-  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
-    try {
-      const headers = new Headers(requestInit.headers);
-      if (publishableKey) {
-        headers.set("X-Publishable-Key", publishableKey);
-      }
-      if (authToken) {
-        headers.set("Authorization", `Bearer ${authToken}`);
-      }
-      if (!headers.has("Content-Type") && requestInit.body && !(requestInit.body instanceof FormData)) {
-        headers.set("Content-Type", "application/json");
-      }
-      const redactedHeaders = redactSensitiveHeaders(headers);
-      debugLog(debug, "request", url, {
-        method: requestInit.method || "GET",
-        headers: redactedHeaders,
-        attempt: attempt + 1
-      });
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), timeout);
-      const response = await fetch(`${baseUrl}${url}`, {
-        ...requestInit,
-        headers,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      const requestId = response.headers.get("x-request-id") ?? void 0;
-      debugLog(debug, "response", url, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: redactSensitiveHeaders(response.headers)
-      });
-      if (!response.ok) {
-        if (isUsageLimitExceededResponse(response)) {
-          const limit = parseInt(
-            response.headers.get("X-Usage-Limit") || "0",
-            10
-          );
-          const current = parseInt(
-            response.headers.get("X-Usage-Current") || "0",
-            10
-          );
-          const remaining = parseInt(
-            response.headers.get("X-Usage-Remaining") || "0",
-            10
-          );
-          throw attachRequestId(
-            createUsageLimitError(
-              `Monthly API usage limit exceeded (${current.toLocaleString()}/${limit.toLocaleString()})`,
-              { limit, current, remaining },
-              {
-                url,
-                method: requestInit.method || "GET",
-                attempt: attempt + 1
-              },
-              "Monthly API call limit exceeded. Please upgrade your plan.",
-              "Upgrade your tenant plan to increase the monthly API call limit."
-            ),
-            requestId
-          );
-        }
-        const parsed = await parseErrorBody(response);
-        if (response.status === 401 && onUnauthorized && customerToken && !hasRetried401 && parsed.reason === "token_expired") {
-          hasRetried401 = true;
-          try {
-            const newToken = await onUnauthorized();
-            if (newToken) {
-              authToken = newToken;
-              continue;
-            }
-          } catch {
-          }
-        }
-        const details = {
-          url,
-          method: requestInit.method || "GET",
-          attempt: attempt + 1
-        };
-        if (NON_RETRYABLE_STATUSES.includes(response.status)) {
-          throw createHttpStatusError(
-            response.status,
-            parsed,
-            details,
-            requestId
-          );
-        }
-        const error = attachRequestId(
-          createNetworkError(
-            parsed.errorMessage,
-            response.status,
-            details,
-            parsed.userMessage,
-            getErrorSuggestion(response.status)
-          ),
-          requestId
-        );
-        const method2 = (requestInit.method || "GET").toUpperCase();
-        if (attempt < retryConfig.maxRetries && SAFE_METHODS.includes(method2) && retryConfig.retryableStatuses.includes(response.status)) {
-          lastError = error;
-          const retryDelay = retryConfig.retryDelay(attempt);
-          debugLog(debug, "error", `Retrying in ${retryDelay}ms...`, error);
-          await delay(retryDelay);
-          continue;
-        }
-        throw error;
-      }
-      return response;
-    } catch (error) {
-      debugLog(debug, "error", url, error);
-      const method2 = (requestInit.method || "GET").toUpperCase();
-      const isSafe = SAFE_METHODS.includes(method2);
-      if (error instanceof Error && error.name === "AbortError") {
-        const timeoutError = createTimeoutError(
-          `Request timed out after ${timeout}ms.`,
-          { url, timeout, attempt: attempt + 1 },
-          "The request timed out.",
-          "Please check your network connection or try again later."
-        );
-        if (isSafe && attempt < retryConfig.maxRetries) {
-          lastError = timeoutError;
-          await delay(retryConfig.retryDelay(attempt));
-          continue;
-        }
-        throw timeoutError;
-      }
-      if (error instanceof TypeError) {
-        const networkError = createNetworkError(
-          "Network connection failed.",
-          void 0,
-          { url, originalError: error.message, attempt: attempt + 1 },
-          "Network connection failed.",
-          "Please check your internet connection and try again."
-        );
-        if (isSafe && attempt < retryConfig.maxRetries) {
-          lastError = networkError;
-          await delay(retryConfig.retryDelay(attempt));
-          continue;
-        }
-        throw networkError;
-      }
-      if (error instanceof NetworkError || error instanceof TimeoutError) {
-        if (isSafe && attempt < retryConfig.maxRetries && error.status && !NON_RETRYABLE_STATUSES.includes(error.status) && retryConfig.retryableStatuses.includes(error.status)) {
-          lastError = error;
-          await delay(retryConfig.retryDelay(attempt));
-          continue;
-        }
-        throw error;
-      }
-      if (error instanceof SDKError) {
-        throw error;
-      }
-      const unknownError = createNetworkError(
-        error instanceof Error ? error.message : "An unknown network error occurred.",
-        void 0,
-        { url, originalError: error, attempt: attempt + 1 },
-        "An unknown error occurred.",
-        "Please try again later."
-      );
-      if (isSafe && attempt < retryConfig.maxRetries) {
-        lastError = unknownError;
-        await delay(retryConfig.retryDelay(attempt));
-        continue;
-      }
-      throw unknownError;
-    }
-  }
-  throw lastError ?? new NetworkError("Request failed after retries");
-}
-
-// src/core/collection/http-client.ts
-var HttpClient = class {
-  constructor(publishableKey, secretKey, getCustomerToken, onUnauthorized, onRequestId, apiUrl) {
-    this.publishableKey = requirePublishableKeyForSecret(
-      "CollectionClient",
-      publishableKey,
-      secretKey
-    );
-    this.secretKey = secretKey;
-    this.getCustomerToken = getCustomerToken;
-    this.onUnauthorized = onUnauthorized;
-    this.onRequestId = onRequestId;
-    this.apiUrl = apiUrl;
-  }
-  get defaultOptions() {
-    const opts = {
-      apiUrl: this.apiUrl,
-      publishableKey: this.publishableKey,
-      secretKey: this.secretKey
-    };
-    const token = this.getCustomerToken?.();
-    if (token) {
-      opts.customerToken = token;
-      if (this.onUnauthorized) {
-        opts.onUnauthorized = this.onUnauthorized;
-      }
-    }
-    return opts;
-  }
-  async fetchWithTracking(url, opts) {
-    try {
-      const response = await httpFetch(url, opts);
-      this.onRequestId?.(response.headers.get("x-request-id") ?? null);
-      return response;
-    } catch (err) {
-      const id = err instanceof SDKError ? err.requestId ?? null : null;
-      this.onRequestId?.(id);
-      throw err;
-    }
-  }
-  buildUrl(endpoint, options) {
-    if (!options) return endpoint;
-    const queryString = (0, import_qs_esm.stringify)(options, { addQueryPrefix: true });
-    return queryString ? `${endpoint}${queryString}` : endpoint;
-  }
-  assertJsonResponse(response) {
-    const contentType = response.headers.get("content-type");
-    if (!contentType?.includes("application/json")) {
-      throw createApiError("Response is not in JSON format.", response.status, {
-        contentType
-      });
-    }
-  }
-  /**
-   * Parse Payload CMS find response (list query)
-   * Returns native Payload response structure
-   */
-  async parseFindResponse(response) {
-    const contentType = response.headers.get("content-type");
-    try {
-      this.assertJsonResponse(response);
-      const jsonData = await response.json();
-      if (jsonData.docs === void 0) {
-        throw createApiError("Invalid find response.", response.status, {
-          jsonData
-        });
-      }
-      return {
-        docs: jsonData.docs,
-        totalDocs: jsonData.totalDocs ?? 0,
-        limit: jsonData.limit || 20,
-        totalPages: jsonData.totalPages ?? 0,
-        page: jsonData.page || 1,
-        pagingCounter: jsonData.pagingCounter || 1,
-        hasPrevPage: jsonData.hasPrevPage ?? false,
-        hasNextPage: jsonData.hasNextPage ?? false,
-        prevPage: jsonData.prevPage ?? null,
-        nextPage: jsonData.nextPage ?? null
-      };
-    } catch (error) {
-      if (error instanceof SDKError) throw error;
-      throw createApiError("Failed to parse response.", response.status, {
-        contentType,
-        error: error instanceof Error ? error.message : error
-      });
-    }
-  }
-  /**
-   * Parse Payload CMS mutation response (create/update)
-   * Returns native Payload response structure
-   */
-  async parseMutationResponse(response) {
-    const contentType = response.headers.get("content-type");
-    try {
-      this.assertJsonResponse(response);
-      const jsonData = await response.json();
-      if (jsonData.doc === void 0) {
-        throw createApiError("Invalid mutation response.", response.status, {
-          jsonData
-        });
-      }
-      return {
-        message: jsonData.message || "",
-        doc: jsonData.doc,
-        errors: jsonData.errors
-      };
-    } catch (error) {
-      if (error instanceof SDKError) throw error;
-      throw createApiError("Failed to parse response.", response.status, {
-        contentType,
-        error: error instanceof Error ? error.message : error
-      });
-    }
-  }
-  /**
-   * Parse Payload CMS document response (findById/delete)
-   * Returns document directly without wrapper
-   */
-  async parseDocumentResponse(response) {
-    const contentType = response.headers.get("content-type");
-    try {
-      this.assertJsonResponse(response);
-      const jsonData = await response.json();
-      return jsonData;
-    } catch (error) {
-      if (error instanceof SDKError) throw error;
-      throw createApiError("Failed to parse response.", response.status, {
-        contentType,
-        error: error instanceof Error ? error.message : error
-      });
-    }
-  }
-};
-
-// src/core/collection/collection-client.ts
-function buildPayloadFormData(data, file, filename) {
-  const formData = new FormData();
-  formData.append("file", file, filename);
-  if (data != null) {
-    formData.append("_payload", JSON.stringify(data));
-  }
-  return formData;
-}
-var CollectionClient = class extends HttpClient {
-  from(collection) {
-    return new CollectionQueryBuilder(this, collection);
-  }
-  // ============================================================================
-  // Payload-native methods
-  // ============================================================================
-  /**
-   * Find documents (list query)
-   * GET /api/{collection}
-   */
-  async requestFind(endpoint, options) {
-    const url = this.buildUrl(endpoint, options);
-    const response = await this.fetchWithTracking(url, {
-      ...this.defaultOptions,
-      method: "GET"
-    });
-    return this.parseFindResponse(response);
-  }
-  /**
-   * Find-like response from a custom endpoint
-   * POST /api/...custom-endpoint
-   */
-  async requestFindEndpoint(endpoint, data) {
-    const response = await this.fetchWithTracking(endpoint, {
-      ...this.defaultOptions,
-      method: "POST",
-      body: data ? JSON.stringify(data) : void 0
-    });
-    return this.parseFindResponse(response);
-  }
-  /**
-   * Find-like response from a cacheable GET custom endpoint.
-   */
-  async requestFindEndpointGet(endpoint) {
-    const response = await this.fetchWithTracking(endpoint, {
-      ...this.defaultOptions,
-      method: "GET"
-    });
-    return this.parseFindResponse(response);
-  }
-  /**
-   * Find document by ID
-   * GET /api/{collection}/{id}
-   */
-  async requestFindById(endpoint, options) {
-    const url = this.buildUrl(endpoint, options);
-    const response = await this.fetchWithTracking(url, {
-      ...this.defaultOptions,
-      method: "GET"
-    });
-    return this.parseDocumentResponse(response);
-  }
-  /**
-   * Create document
-   * POST /api/{collection}
-   */
-  async requestCreate(endpoint, data) {
-    const response = await this.fetchWithTracking(endpoint, {
-      ...this.defaultOptions,
-      method: "POST",
-      body: data ? JSON.stringify(data) : void 0
-    });
-    return this.parseMutationResponse(response);
-  }
-  /**
-   * Update document
-   * PATCH /api/{collection}/{id}
-   */
-  async requestUpdate(endpoint, data) {
-    const response = await this.fetchWithTracking(endpoint, {
-      ...this.defaultOptions,
-      method: "PATCH",
-      body: data ? JSON.stringify(data) : void 0
-    });
-    return this.parseMutationResponse(response);
-  }
-  /**
-   * Count documents
-   * GET /api/{collection}/count
-   */
-  async requestCount(endpoint, options) {
-    const url = this.buildUrl(endpoint, options);
-    const response = await this.fetchWithTracking(url, {
-      ...this.defaultOptions,
-      method: "GET"
-    });
-    return this.parseDocumentResponse(response);
-  }
-  /**
-   * Update multiple documents (bulk update)
-   * PATCH /api/{collection}
-   */
-  async requestUpdateMany(endpoint, data) {
-    const response = await this.fetchWithTracking(endpoint, {
-      ...this.defaultOptions,
-      method: "PATCH",
-      body: JSON.stringify(data)
-    });
-    return this.parseFindResponse(response);
-  }
-  /**
-   * Delete document
-   * DELETE /api/{collection}/{id}
-   */
-  async requestDelete(endpoint) {
-    const response = await this.fetchWithTracking(endpoint, {
-      ...this.defaultOptions,
-      method: "DELETE"
-    });
-    return this.parseDocumentResponse(response);
-  }
-  /**
-   * Delete multiple documents (bulk delete)
-   * DELETE /api/{collection}
-   */
-  async requestDeleteMany(endpoint, data) {
-    const response = await this.fetchWithTracking(endpoint, {
-      ...this.defaultOptions,
-      method: "DELETE",
-      body: JSON.stringify(data)
-    });
-    return this.parseFindResponse(response);
-  }
-  /**
-   * Create document with file upload
-   * POST /api/{collection} (multipart/form-data)
-   */
-  async requestCreateWithFile(endpoint, data, file, filename) {
-    const response = await this.fetchWithTracking(endpoint, {
-      ...this.defaultOptions,
-      method: "POST",
-      body: buildPayloadFormData(data, file, filename)
-    });
-    return this.parseMutationResponse(response);
-  }
-  /**
-   * Update document with file upload
-   * PATCH /api/{collection}/{id} (multipart/form-data)
-   */
-  async requestUpdateWithFile(endpoint, data, file, filename) {
-    const response = await this.fetchWithTracking(endpoint, {
-      ...this.defaultOptions,
-      method: "PATCH",
-      body: buildPayloadFormData(data, file, filename)
-    });
-    return this.parseMutationResponse(response);
+    }, delay);
   }
 };
 
@@ -1952,40 +1117,26 @@ function createReadOnlyQueryHooksFacade(hooks) {
     invalidateCustomerQueries: hooks.invalidateCustomerQueries.bind(hooks),
     getCustomerData: hooks.getCustomerData.bind(hooks),
     setCustomerData: hooks.setCustomerData.bind(hooks),
-    useProductListingGroupsQuery: hooks.useProductListingGroupsQuery.bind(hooks),
-    useSuspenseProductListingGroupsQuery: hooks.useSuspenseProductListingGroupsQuery.bind(hooks),
-    useInfiniteProductListingGroupsQuery: hooks.useInfiniteProductListingGroupsQuery.bind(hooks),
-    useSuspenseInfiniteProductListingGroupsQuery: hooks.useSuspenseInfiniteProductListingGroupsQuery.bind(hooks),
-    prefetchProductListingGroupsQuery: hooks.prefetchProductListingGroupsQuery.bind(hooks),
-    prefetchInfiniteProductListingGroupsQuery: hooks.prefetchInfiniteProductListingGroupsQuery.bind(hooks),
+    useProductListingGroupsCatalogQuery: hooks.useProductListingGroupsCatalogQuery.bind(hooks),
+    useSuspenseProductListingGroupsCatalogQuery: hooks.useSuspenseProductListingGroupsCatalogQuery.bind(hooks),
+    useInfiniteProductListingGroupsCatalogQuery: hooks.useInfiniteProductListingGroupsCatalogQuery.bind(hooks),
+    useSuspenseInfiniteProductListingGroupsCatalogQuery: hooks.useSuspenseInfiniteProductListingGroupsCatalogQuery.bind(hooks),
+    prefetchProductListingGroupsCatalogQuery: hooks.prefetchProductListingGroupsCatalogQuery.bind(hooks),
+    prefetchInfiniteProductListingGroupsCatalogQuery: hooks.prefetchInfiniteProductListingGroupsCatalogQuery.bind(hooks),
+    useProductListingPage: hooks.useProductListingPage.bind(hooks),
+    useSuspenseProductListingPage: hooks.useSuspenseProductListingPage.bind(hooks),
+    useInfiniteProductListingPage: hooks.useInfiniteProductListingPage.bind(hooks),
+    prefetchProductListingPage: hooks.prefetchProductListingPage.bind(hooks),
+    prefetchInfiniteProductListingPage: hooks.prefetchInfiniteProductListingPage.bind(hooks),
     useProductDetail: hooks.useProductDetail.bind(hooks),
     useProductDetailBySlug: hooks.useProductDetailBySlug.bind(hooks),
     useProductDetailById: hooks.useProductDetailById.bind(hooks)
   };
 }
 function createQueryHooks(client, queryClient = getQueryClient()) {
-  const config = client.getConfig();
-  const onUnauthorized = async () => {
-    try {
-      const result = await client.customer.auth.refreshToken();
-      return result.token ?? null;
-    } catch {
-      return null;
-    }
-  };
-  const collectionClient = new CollectionClient(
-    config.publishableKey,
-    void 0,
-    () => client.customer.auth.getToken(),
-    onUnauthorized,
-    (id) => {
-      client.lastRequestId = id;
-    },
-    config.apiUrl
-  );
   const hooks = new QueryHooks(
     queryClient,
-    collectionClient,
+    client.collections,
     client.customer.auth,
     client.commerce
   );