@propeller-commerce/propeller-sdk-v2 0.11.4 → 0.12.0

package/dist/esm/service/ClusterOptionService.js

@@ -0,0 +1,95 @@
+import { runOperation } from './runOperation.js';
+import { document as clusterOptionDoc } from '../generated/operations/clusterOption.js';
+import { document as clusterOptionAssignProductsDoc } from '../generated/operations/clusterOptionAssignProducts.js';
+import { document as clusterOptionMoveAboveDoc } from '../generated/operations/clusterOptionMoveAbove.js';
+import { document as clusterOptionMoveBelowDoc } from '../generated/operations/clusterOptionMoveBelow.js';
+import { document as clusterOptionProductCreateDoc } from '../generated/operations/clusterOptionProductCreate.js';
+import { document as clusterOptionProductDeleteDoc } from '../generated/operations/clusterOptionProductDelete.js';
+import { document as clusterOptionProductUpdateDoc } from '../generated/operations/clusterOptionProductUpdate.js';
+import { document as clusterOptionRemoveProductsDoc } from '../generated/operations/clusterOptionRemoveProducts.js';
+import { document as clusterOptionsDoc } from '../generated/operations/clusterOptions.js';
+/**
+ Service for ClusterOption-related GraphQL operations
+ */
+export function clusterOptionService(client) {
+    return {
+        /**
+           Retrieve a single cluster option by global identifier.
+           */
+        async getClusterOption(variables) {
+            const result = await runOperation(client, clusterOptionDoc, 'clusterOption', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.clusterOption;
+        },
+        /**
+           Attach existing products to a cluster option so they become selectable for it.
+           */
+        async clusterOptionAssignProducts(variables) {
+            const result = await runOperation(client, clusterOptionAssignProductsDoc, 'clusterOptionAssignProducts', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.clusterOptionAssignProducts;
+        },
+        /**
+           Reorder a cluster option within its cluster so it appears immediately before another option.
+           */
+        async clusterOptionMoveAbove(variables) {
+            const result = await runOperation(client, clusterOptionMoveAboveDoc, 'clusterOptionMoveAbove', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.clusterOptionMoveAbove;
+        },
+        /**
+           Reorder a cluster option within its cluster so it appears immediately after another option.
+           */
+        async clusterOptionMoveBelow(variables) {
+            const result = await runOperation(client, clusterOptionMoveBelowDoc, 'clusterOptionMoveBelow', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.clusterOptionMoveBelow;
+        },
+        /**
+           Create a product directly within a cluster option.
+           */
+        async clusterOptionProductCreate(variables) {
+            const result = await runOperation(client, clusterOptionProductCreateDoc, 'clusterOptionProductCreate', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.clusterOptionProductCreate;
+        },
+        /**
+           Remove a product attached to a cluster option from the catalogue.
+           */
+        async clusterOptionProductDelete(variables) {
+            const result = await runOperation(client, clusterOptionProductDeleteDoc, 'clusterOptionProductDelete', { ...variables });
+            return result.data.clusterOptionProductDelete;
+        },
+        /**
+           Apply a partial update to a product attached to a cluster option.
+           */
+        async clusterOptionProductUpdate(variables) {
+            const result = await runOperation(client, clusterOptionProductUpdateDoc, 'clusterOptionProductUpdate', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.clusterOptionProductUpdate;
+        },
+        /**
+           Detach products from a cluster option.
+           */
+        async clusterOptionRemoveProducts(variables) {
+            const result = await runOperation(client, clusterOptionRemoveProductsDoc, 'clusterOptionRemoveProducts', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.clusterOptionRemoveProducts;
+        },
+        /**
+           Search cluster options with filtering and pagination.
+           */
+        async getClusterOptions(variables) {
+            const result = await runOperation(client, clusterOptionsDoc, 'clusterOptions', { ...variables });
+            return result.data.clusterOptions;
+        },
+    };
+}
+/**
+ * Backwards-compatible class form. New code should call `clusterOptionService(client)`.
+ */
+export class ClusterOptionService {
+    constructor(client) { this._svc = clusterOptionService(client); }
+    getClusterOption(variables) { return this._svc.getClusterOption(variables); }
+    clusterOptionAssignProducts(variables) { return this._svc.clusterOptionAssignProducts(variables); }
+    clusterOptionMoveAbove(variables) { return this._svc.clusterOptionMoveAbove(variables); }
+    clusterOptionMoveBelow(variables) { return this._svc.clusterOptionMoveBelow(variables); }
+    clusterOptionProductCreate(variables) { return this._svc.clusterOptionProductCreate(variables); }
+    clusterOptionProductDelete(variables) { return this._svc.clusterOptionProductDelete(variables); }
+    clusterOptionProductUpdate(variables) { return this._svc.clusterOptionProductUpdate(variables); }
+    clusterOptionRemoveProducts(variables) { return this._svc.clusterOptionRemoveProducts(variables); }
+    getClusterOptions(variables) { return this._svc.getClusterOptions(variables); }
+}

package/dist/esm/service/ClusterService.js

@@ -1,3 +1,13 @@
+import { document as clusterAddToCategoryDoc } from '../generated/operations/clusterAddToCategory.js';
+import { document as clusterAssignProductDoc } from '../generated/operations/clusterAssignProduct.js';
+import { document as clusterCategoryMoveAboveDoc } from '../generated/operations/clusterCategoryMoveAbove.js';
+import { document as clusterCategoryMoveBelowDoc } from '../generated/operations/clusterCategoryMoveBelow.js';
+import { document as clusterRemoveFromCategoryDoc } from '../generated/operations/clusterRemoveFromCategory.js';
+import { document as clusterSetDefaultCategoryDoc } from '../generated/operations/clusterSetDefaultCategory.js';
+import { document as clusterUnassignProductDoc } from '../generated/operations/clusterUnassignProduct.js';
+import { document as clustersDoc } from '../generated/operations/clusters.js';
+import { document as clustersBulkAddToCategoryDoc } from '../generated/operations/clustersBulkAddToCategory.js';
+import { document as clustersBulkRemoveFromCategoryDoc } from '../generated/operations/clustersBulkRemoveFromCategory.js';
 import { runOperation } from './runOperation.js';
 import { document as clusterConfigDoc } from '../generated/operations/clusterConfig.js';
 import { document as clusterDoc } from '../generated/operations/cluster.js';
@@ -64,6 +74,76 @@ export function clusterService(client) {
             const result = await runOperation(client, clusterDeleteDoc, 'clusterDelete', variables);
             return result.data.clusterDelete;
         },
+        /**
+           clusterAddToCategory operation
+           */
+        async clusterAddToCategory(variables) {
+            const result = await runOperation(client, clusterAddToCategoryDoc, 'clusterAddToCategory', { ...variables });
+            return result.data.clusterAddToCategory;
+        },
+        /**
+           Attach a single existing product to a cluster. The product will be detached from a category or another cluster.
+           */
+        async clusterAssignProduct(variables) {
+            const result = await runOperation(client, clusterAssignProductDoc, 'clusterAssignProduct', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.clusterAssignProduct;
+        },
+        /**
+           Reorder a cluster within its category so it appears immediately before another cluster.
+           */
+        async clusterCategoryMoveAbove(variables) {
+            const result = await runOperation(client, clusterCategoryMoveAboveDoc, 'clusterCategoryMoveAbove', { ...variables });
+            return result.data.clusterCategoryMoveAbove;
+        },
+        /**
+           Reorder a cluster within its category so it appears immediately after another cluster.
+           */
+        async clusterCategoryMoveBelow(variables) {
+            const result = await runOperation(client, clusterCategoryMoveBelowDoc, 'clusterCategoryMoveBelow', { ...variables });
+            return result.data.clusterCategoryMoveBelow;
+        },
+        /**
+           clusterRemoveFromCategory operation
+           */
+        async clusterRemoveFromCategory(variables) {
+            const result = await runOperation(client, clusterRemoveFromCategoryDoc, 'clusterRemoveFromCategory', { ...variables });
+            return result.data.clusterRemoveFromCategory;
+        },
+        /**
+           clusterSetDefaultCategory operation
+           */
+        async clusterSetDefaultCategory(variables) {
+            const result = await runOperation(client, clusterSetDefaultCategoryDoc, 'clusterSetDefaultCategory', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.clusterSetDefaultCategory;
+        },
+        /**
+           Detach a single product from its current cluster.
+           */
+        async clusterUnassignProduct(variables) {
+            const result = await runOperation(client, clusterUnassignProductDoc, 'clusterUnassignProduct', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.clusterUnassignProduct;
+        },
+        /**
+           Search the catalogue for clusters matching the supplied criteria.
+           */
+        async getClusters(variables) {
+            const result = await runOperation(client, clustersDoc, 'clusters', { ...variables });
+            return result.data.clusters;
+        },
+        /**
+           clustersBulkAddToCategory operation
+           */
+        async clustersBulkAddToCategory(variables) {
+            const result = await runOperation(client, clustersBulkAddToCategoryDoc, 'clustersBulkAddToCategory', { ...variables });
+            return result.data.clustersBulkAddToCategory;
+        },
+        /**
+           clustersBulkRemoveFromCategory operation
+           */
+        async clustersBulkRemoveFromCategory(variables) {
+            const result = await runOperation(client, clustersBulkRemoveFromCategoryDoc, 'clustersBulkRemoveFromCategory', { ...variables });
+            return result.data.clustersBulkRemoveFromCategory;
+        },
     };
 }
 /**
@@ -96,4 +176,14 @@ export class ClusterService {
      * @param variables Cluster delete variables
      */
     deleteCluster(variables) { return this._svc.deleteCluster(variables); }
+    clusterAddToCategory(variables) { return this._svc.clusterAddToCategory(variables); }
+    clusterAssignProduct(variables) { return this._svc.clusterAssignProduct(variables); }
+    clusterCategoryMoveAbove(variables) { return this._svc.clusterCategoryMoveAbove(variables); }
+    clusterCategoryMoveBelow(variables) { return this._svc.clusterCategoryMoveBelow(variables); }
+    clusterRemoveFromCategory(variables) { return this._svc.clusterRemoveFromCategory(variables); }
+    clusterSetDefaultCategory(variables) { return this._svc.clusterSetDefaultCategory(variables); }
+    clusterUnassignProduct(variables) { return this._svc.clusterUnassignProduct(variables); }
+    getClusters(variables) { return this._svc.getClusters(variables); }
+    clustersBulkAddToCategory(variables) { return this._svc.clustersBulkAddToCategory(variables); }
+    clustersBulkRemoveFromCategory(variables) { return this._svc.clustersBulkRemoveFromCategory(variables); }
 }

package/dist/esm/service/ProductService.js

@@ -1,3 +1,42 @@
+import { document as baseProductCategoryMoveAboveDoc } from '../generated/operations/baseProductCategoryMoveAbove.js';
+import { document as baseProductCategoryMoveAboveByUuidsDoc } from '../generated/operations/baseProductCategoryMoveAboveByUuids.js';
+import { document as baseProductCategoryMoveBelowDoc } from '../generated/operations/baseProductCategoryMoveBelow.js';
+import { document as baseProductCategoryMoveBelowByUuidsDoc } from '../generated/operations/baseProductCategoryMoveBelowByUuids.js';
+import { document as baseProductCategoryMoveToBottomDoc } from '../generated/operations/baseProductCategoryMoveToBottom.js';
+import { document as baseProductCategoryMoveToBottomByUuidsDoc } from '../generated/operations/baseProductCategoryMoveToBottomByUuids.js';
+import { document as baseProductCategoryMoveToTopDoc } from '../generated/operations/baseProductCategoryMoveToTop.js';
+import { document as baseProductCategoryMoveToTopByUuidsDoc } from '../generated/operations/baseProductCategoryMoveToTopByUuids.js';
+import { document as baseProductsDoc } from '../generated/operations/baseProducts.js';
+import { document as productAddToCategoryDoc } from '../generated/operations/productAddToCategory.js';
+import { document as productAssignToClusterDoc } from '../generated/operations/productAssignToCluster.js';
+import { document as productCategoryMoveAboveDoc } from '../generated/operations/productCategoryMoveAbove.js';
+import { document as productCategoryMoveBelowDoc } from '../generated/operations/productCategoryMoveBelow.js';
+import { document as productCategoryMoveToBottomDoc } from '../generated/operations/productCategoryMoveToBottom.js';
+import { document as productCategoryMoveToTopDoc } from '../generated/operations/productCategoryMoveToTop.js';
+import { document as productClusterMoveAboveDoc } from '../generated/operations/productClusterMoveAbove.js';
+import { document as productClusterMoveBelowDoc } from '../generated/operations/productClusterMoveBelow.js';
+import { document as productClusterOptionMoveAboveDoc } from '../generated/operations/productClusterOptionMoveAbove.js';
+import { document as productClusterOptionMoveBelowDoc } from '../generated/operations/productClusterOptionMoveBelow.js';
+import { document as productRemoveFromCategoryDoc } from '../generated/operations/productRemoveFromCategory.js';
+import { document as productSearchBatchMetricsDoc } from '../generated/operations/productSearchBatchMetrics.js';
+import { document as productSearchBatchMetricsFailedJobsDoc } from '../generated/operations/productSearchBatchMetricsFailedJobs.js';
+import { document as productSearchBatchMetricsHourlyDoc } from '../generated/operations/productSearchBatchMetricsHourly.js';
+import { document as productSearchBatchMetricsQueueStatusDoc } from '../generated/operations/productSearchBatchMetricsQueueStatus.js';
+import { document as productSearchByCategoryDoc } from '../generated/operations/productSearchByCategory.js';
+import { document as productSearchCategoriesIndexDoc } from '../generated/operations/productSearchCategoriesIndex.js';
+import { document as productSearchClustersIndexDoc } from '../generated/operations/productSearchClustersIndex.js';
+import { document as productSearchFullReindexCancelDoc } from '../generated/operations/productSearchFullReindexCancel.js';
+import { document as productSearchFullReindexStartDoc } from '../generated/operations/productSearchFullReindexStart.js';
+import { document as productSearchProductsIndexDoc } from '../generated/operations/productSearchProductsIndex.js';
+import { document as productSearchReindexLockDoc } from '../generated/operations/productSearchReindexLock.js';
+import { document as productSearchReindexLockForceReleaseDoc } from '../generated/operations/productSearchReindexLockForceRelease.js';
+import { document as productSearchReindexStatusDoc } from '../generated/operations/productSearchReindexStatus.js';
+import { document as productSearchSolrDoc } from '../generated/operations/productSearchSolr.js';
+import { document as productSetDefaultCategoryDoc } from '../generated/operations/productSetDefaultCategory.js';
+import { document as productUnassignFromClusterDoc } from '../generated/operations/productUnassignFromCluster.js';
+import { document as productsBulkAddToCategoryDoc } from '../generated/operations/productsBulkAddToCategory.js';
+import { document as productsBulkRemoveFromCategoryDoc } from '../generated/operations/productsBulkRemoveFromCategory.js';
+import { document as productsRawDoc } from '../generated/operations/productsRaw.js';
 import { runOperation } from './runOperation.js';
 import { document as productDoc } from '../generated/operations/product.js';
 import { document as productsDoc } from '../generated/operations/products.js';
@@ -119,6 +158,279 @@ export function productService(client) {
             const result = await runOperation(client, attributeResultByProductIdDoc, 'attributeResultByProductId', { productId, input });
             return result.data.attributeResultByProductId;
         },
+        /**
+           baseProductCategoryMoveAbove operation
+           */
+        async baseProductCategoryMoveAbove(variables) {
+            const result = await runOperation(client, baseProductCategoryMoveAboveDoc, 'baseProductCategoryMoveAbove', { ...variables });
+            return result.data.baseProductCategoryMoveAbove;
+        },
+        /**
+           baseProductCategoryMoveAboveByUuids operation
+           */
+        async baseProductCategoryMoveAboveByUuids(variables) {
+            const result = await runOperation(client, baseProductCategoryMoveAboveByUuidsDoc, 'baseProductCategoryMoveAboveByUuids', { ...variables });
+            return result.data.baseProductCategoryMoveAboveByUuids;
+        },
+        /**
+           baseProductCategoryMoveBelow operation
+           */
+        async baseProductCategoryMoveBelow(variables) {
+            const result = await runOperation(client, baseProductCategoryMoveBelowDoc, 'baseProductCategoryMoveBelow', { ...variables });
+            return result.data.baseProductCategoryMoveBelow;
+        },
+        /**
+           baseProductCategoryMoveBelowByUuids operation
+           */
+        async baseProductCategoryMoveBelowByUuids(variables) {
+            const result = await runOperation(client, baseProductCategoryMoveBelowByUuidsDoc, 'baseProductCategoryMoveBelowByUuids', { ...variables });
+            return result.data.baseProductCategoryMoveBelowByUuids;
+        },
+        /**
+           baseProductCategoryMoveToBottom operation
+           */
+        async baseProductCategoryMoveToBottom(variables) {
+            const result = await runOperation(client, baseProductCategoryMoveToBottomDoc, 'baseProductCategoryMoveToBottom', { ...variables });
+            return result.data.baseProductCategoryMoveToBottom;
+        },
+        /**
+           baseProductCategoryMoveToBottomByUuids operation
+           */
+        async baseProductCategoryMoveToBottomByUuids(variables) {
+            const result = await runOperation(client, baseProductCategoryMoveToBottomByUuidsDoc, 'baseProductCategoryMoveToBottomByUuids', { ...variables });
+            return result.data.baseProductCategoryMoveToBottomByUuids;
+        },
+        /**
+           baseProductCategoryMoveToTop operation
+           */
+        async baseProductCategoryMoveToTop(variables) {
+            const result = await runOperation(client, baseProductCategoryMoveToTopDoc, 'baseProductCategoryMoveToTop', { ...variables });
+            return result.data.baseProductCategoryMoveToTop;
+        },
+        /**
+           baseProductCategoryMoveToTopByUuids operation
+           */
+        async baseProductCategoryMoveToTopByUuids(variables) {
+            const result = await runOperation(client, baseProductCategoryMoveToTopByUuidsDoc, 'baseProductCategoryMoveToTopByUuids', { ...variables });
+            return result.data.baseProductCategoryMoveToTopByUuids;
+        },
+        /**
+           Search both products and clusters in a single result set.
+           */
+        async getBaseProducts(variables) {
+            const result = await runOperation(client, baseProductsDoc, 'baseProducts', { ...variables });
+            return result.data.baseProducts;
+        },
+        /**
+           productAddToCategory operation
+           */
+        async productAddToCategory(variables) {
+            const result = await runOperation(client, productAddToCategoryDoc, 'productAddToCategory', { ...variables });
+            return result.data.productAddToCategory;
+        },
+        /**
+           Attach an existing product to a cluster.
+           */
+        async productAssignToCluster(variables) {
+            const result = await runOperation(client, productAssignToClusterDoc, 'productAssignToCluster', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.productAssignToCluster;
+        },
+        /**
+           productCategoryMoveAbove operation
+           */
+        async productCategoryMoveAbove(variables) {
+            const result = await runOperation(client, productCategoryMoveAboveDoc, 'productCategoryMoveAbove', { ...variables });
+            return result.data.productCategoryMoveAbove;
+        },
+        /**
+           productCategoryMoveBelow operation
+           */
+        async productCategoryMoveBelow(variables) {
+            const result = await runOperation(client, productCategoryMoveBelowDoc, 'productCategoryMoveBelow', { ...variables });
+            return result.data.productCategoryMoveBelow;
+        },
+        /**
+           productCategoryMoveToBottom operation
+           */
+        async productCategoryMoveToBottom(variables) {
+            const result = await runOperation(client, productCategoryMoveToBottomDoc, 'productCategoryMoveToBottom', { ...variables });
+            return result.data.productCategoryMoveToBottom;
+        },
+        /**
+           productCategoryMoveToTop operation
+           */
+        async productCategoryMoveToTop(variables) {
+            const result = await runOperation(client, productCategoryMoveToTopDoc, 'productCategoryMoveToTop', { ...variables });
+            return result.data.productCategoryMoveToTop;
+        },
+        /**
+           Reorder a product within its cluster so it appears immediately before another product.
+           */
+        async productClusterMoveAbove(variables) {
+            const result = await runOperation(client, productClusterMoveAboveDoc, 'productClusterMoveAbove', { ...variables });
+            return result.data.productClusterMoveAbove;
+        },
+        /**
+           Reorder a product within its cluster so it appears immediately after another product.
+           */
+        async productClusterMoveBelow(variables) {
+            const result = await runOperation(client, productClusterMoveBelowDoc, 'productClusterMoveBelow', { ...variables });
+            return result.data.productClusterMoveBelow;
+        },
+        /**
+           Reorder a product within its cluster option so it appears immediately before another product.
+           */
+        async productClusterOptionMoveAbove(variables) {
+            const result = await runOperation(client, productClusterOptionMoveAboveDoc, 'productClusterOptionMoveAbove', { ...variables });
+            return result.data.productClusterOptionMoveAbove;
+        },
+        /**
+           Reorder a product within its cluster option so it appears immediately after another product.
+           */
+        async productClusterOptionMoveBelow(variables) {
+            const result = await runOperation(client, productClusterOptionMoveBelowDoc, 'productClusterOptionMoveBelow', { ...variables });
+            return result.data.productClusterOptionMoveBelow;
+        },
+        /**
+           productRemoveFromCategory operation
+           */
+        async productRemoveFromCategory(variables) {
+            const result = await runOperation(client, productRemoveFromCategoryDoc, 'productRemoveFromCategory', { ...variables });
+            return result.data.productRemoveFromCategory;
+        },
+        /**
+           Current batch metrics for the current tenant
+           */
+        async getProductSearchBatchMetrics() {
+            const result = await runOperation(client, productSearchBatchMetricsDoc, 'productSearchBatchMetrics', {});
+            return result.data.productSearchBatchMetrics;
+        },
+        /**
+           Failed batch jobs for the current tenant
+           */
+        async getProductSearchBatchMetricsFailedJobs(variables) {
+            const result = await runOperation(client, productSearchBatchMetricsFailedJobsDoc, 'productSearchBatchMetricsFailedJobs', { ...variables });
+            return result.data.productSearchBatchMetricsFailedJobs;
+        },
+        /**
+           Hourly batch metrics for the current tenant (last 48 hours)
+           */
+        async getProductSearchBatchMetricsHourly() {
+            const result = await runOperation(client, productSearchBatchMetricsHourlyDoc, 'productSearchBatchMetricsHourly', {});
+            return result.data.productSearchBatchMetricsHourly;
+        },
+        /**
+           Aggregate status of all batch-related queues
+           */
+        async getProductSearchBatchMetricsQueueStatus() {
+            const result = await runOperation(client, productSearchBatchMetricsQueueStatusDoc, 'productSearchBatchMetricsQueueStatus', {});
+            return result.data.productSearchBatchMetricsQueueStatus;
+        },
+        /**
+           Search for products across multiple categories. Each category is searched separately with the same filters applied. Results are grouped by category ID for dataloader patterns.
+           */
+        async getProductSearchByCategory(variables) {
+            const result = await runOperation(client, productSearchByCategoryDoc, 'productSearchByCategory', { ...variables });
+            return result.data.productSearchByCategory;
+        },
+        /**
+           Queue one or more categories for indexing
+           */
+        async productSearchCategoriesIndex(variables) {
+            const result = await runOperation(client, productSearchCategoriesIndexDoc, 'productSearchCategoriesIndex', { ...variables });
+            return result.data.productSearchCategoriesIndex;
+        },
+        /**
+           Queue one or more clusters for indexing
+           */
+        async productSearchClustersIndex(variables) {
+            const result = await runOperation(client, productSearchClustersIndexDoc, 'productSearchClustersIndex', { ...variables });
+            return result.data.productSearchClustersIndex;
+        },
+        /**
+           Cancel a running reindex by its ID
+           */
+        async productSearchFullReindexCancel(variables) {
+            const result = await runOperation(client, productSearchFullReindexCancelDoc, 'productSearchFullReindexCancel', { ...variables });
+            return result.data.productSearchFullReindexCancel;
+        },
+        /**
+           Start a full reindex for the current tenant
+           */
+        async productSearchFullReindexStart(variables) {
+            const result = await runOperation(client, productSearchFullReindexStartDoc, 'productSearchFullReindexStart', { ...variables });
+            return result.data.productSearchFullReindexStart;
+        },
+        /**
+           Queue one or more products for indexing
+           */
+        async productSearchProductsIndex(variables) {
+            const result = await runOperation(client, productSearchProductsIndexDoc, 'productSearchProductsIndex', { ...variables });
+            return result.data.productSearchProductsIndex;
+        },
+        /**
+           Check if a reindex is currently running for the current tenant
+           */
+        async getProductSearchReindexLock() {
+            const result = await runOperation(client, productSearchReindexLockDoc, 'productSearchReindexLock', {});
+            return result.data.productSearchReindexLock;
+        },
+        /**
+           Force release a reindex lock for the current tenant (admin operation)
+           */
+        async productSearchReindexLockForceRelease() {
+            const result = await runOperation(client, productSearchReindexLockForceReleaseDoc, 'productSearchReindexLockForceRelease', {});
+            return result.data.productSearchReindexLockForceRelease;
+        },
+        /**
+           Get the progress of a reindex by its ID
+           */
+        async getProductSearchReindexStatus(variables) {
+            const result = await runOperation(client, productSearchReindexStatusDoc, 'productSearchReindexStatus', { ...variables });
+            return result.data.productSearchReindexStatus;
+        },
+        /**
+           Search for products using Solr (parallel implementation for testing and migration)
+           */
+        async getProductSearchSolr(variables) {
+            const result = await runOperation(client, productSearchSolrDoc, 'productSearchSolr', { ...variables });
+            return result.data.productSearchSolr;
+        },
+        /**
+           productSetDefaultCategory operation
+           */
+        async productSetDefaultCategory(variables) {
+            const result = await runOperation(client, productSetDefaultCategoryDoc, 'productSetDefaultCategory', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.productSetDefaultCategory;
+        },
+        /**
+           Detach a product from its current cluster.
+           */
+        async productUnassignFromCluster(variables) {
+            const result = await runOperation(client, productUnassignFromClusterDoc, 'productUnassignFromCluster', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.productUnassignFromCluster;
+        },
+        /**
+           productsBulkAddToCategory operation
+           */
+        async productsBulkAddToCategory(variables) {
+            const result = await runOperation(client, productsBulkAddToCategoryDoc, 'productsBulkAddToCategory', { ...variables });
+            return result.data.productsBulkAddToCategory;
+        },
+        /**
+           productsBulkRemoveFromCategory operation
+           */
+        async productsBulkRemoveFromCategory(variables) {
+            const result = await runOperation(client, productsBulkRemoveFromCategoryDoc, 'productsBulkRemoveFromCategory', { ...variables });
+            return result.data.productsBulkRemoveFromCategory;
+        },
+        /**
+           Search products with filtering, sorting and pagination, returning raw records without orderlist enrichment.
+           */
+        async getProductsRaw(variables) {
+            const result = await runOperation(client, productsRawDoc, 'productsRaw', { ...variables });
+            return result.data.productsRaw;
+        },
     };
 }
 /**
@@ -188,4 +500,43 @@ export class ProductService {
      * @param input Attribute result search input
      */
     getAttributeResultByProductId(productId, input) { return this._svc.getAttributeResultByProductId(productId, input); }
+    baseProductCategoryMoveAbove(variables) { return this._svc.baseProductCategoryMoveAbove(variables); }
+    baseProductCategoryMoveAboveByUuids(variables) { return this._svc.baseProductCategoryMoveAboveByUuids(variables); }
+    baseProductCategoryMoveBelow(variables) { return this._svc.baseProductCategoryMoveBelow(variables); }
+    baseProductCategoryMoveBelowByUuids(variables) { return this._svc.baseProductCategoryMoveBelowByUuids(variables); }
+    baseProductCategoryMoveToBottom(variables) { return this._svc.baseProductCategoryMoveToBottom(variables); }
+    baseProductCategoryMoveToBottomByUuids(variables) { return this._svc.baseProductCategoryMoveToBottomByUuids(variables); }
+    baseProductCategoryMoveToTop(variables) { return this._svc.baseProductCategoryMoveToTop(variables); }
+    baseProductCategoryMoveToTopByUuids(variables) { return this._svc.baseProductCategoryMoveToTopByUuids(variables); }
+    getBaseProducts(variables) { return this._svc.getBaseProducts(variables); }
+    productAddToCategory(variables) { return this._svc.productAddToCategory(variables); }
+    productAssignToCluster(variables) { return this._svc.productAssignToCluster(variables); }
+    productCategoryMoveAbove(variables) { return this._svc.productCategoryMoveAbove(variables); }
+    productCategoryMoveBelow(variables) { return this._svc.productCategoryMoveBelow(variables); }
+    productCategoryMoveToBottom(variables) { return this._svc.productCategoryMoveToBottom(variables); }
+    productCategoryMoveToTop(variables) { return this._svc.productCategoryMoveToTop(variables); }
+    productClusterMoveAbove(variables) { return this._svc.productClusterMoveAbove(variables); }
+    productClusterMoveBelow(variables) { return this._svc.productClusterMoveBelow(variables); }
+    productClusterOptionMoveAbove(variables) { return this._svc.productClusterOptionMoveAbove(variables); }
+    productClusterOptionMoveBelow(variables) { return this._svc.productClusterOptionMoveBelow(variables); }
+    productRemoveFromCategory(variables) { return this._svc.productRemoveFromCategory(variables); }
+    getProductSearchBatchMetrics() { return this._svc.getProductSearchBatchMetrics(); }
+    getProductSearchBatchMetricsFailedJobs(variables) { return this._svc.getProductSearchBatchMetricsFailedJobs(variables); }
+    getProductSearchBatchMetricsHourly() { return this._svc.getProductSearchBatchMetricsHourly(); }
+    getProductSearchBatchMetricsQueueStatus() { return this._svc.getProductSearchBatchMetricsQueueStatus(); }
+    getProductSearchByCategory(variables) { return this._svc.getProductSearchByCategory(variables); }
+    productSearchCategoriesIndex(variables) { return this._svc.productSearchCategoriesIndex(variables); }
+    productSearchClustersIndex(variables) { return this._svc.productSearchClustersIndex(variables); }
+    productSearchFullReindexCancel(variables) { return this._svc.productSearchFullReindexCancel(variables); }
+    productSearchFullReindexStart(variables) { return this._svc.productSearchFullReindexStart(variables); }
+    productSearchProductsIndex(variables) { return this._svc.productSearchProductsIndex(variables); }
+    getProductSearchReindexLock() { return this._svc.getProductSearchReindexLock(); }
+    productSearchReindexLockForceRelease() { return this._svc.productSearchReindexLockForceRelease(); }
+    getProductSearchReindexStatus(variables) { return this._svc.getProductSearchReindexStatus(variables); }
+    getProductSearchSolr(variables) { return this._svc.getProductSearchSolr(variables); }
+    productSetDefaultCategory(variables) { return this._svc.productSetDefaultCategory(variables); }
+    productUnassignFromCluster(variables) { return this._svc.productUnassignFromCluster(variables); }
+    productsBulkAddToCategory(variables) { return this._svc.productsBulkAddToCategory(variables); }
+    productsBulkRemoveFromCategory(variables) { return this._svc.productsBulkRemoveFromCategory(variables); }
+    getProductsRaw(variables) { return this._svc.getProductsRaw(variables); }
 }

package/dist/esm/service/index.js

@@ -53,3 +53,6 @@ export * from './VerifyTokenService.js';
 export * from './WarehouseAddressService.js';
 export * from './WarehouseService.js';
 export * from './AttributeService.js';
+export * from './AgentService.js';
+export * from './ClusterOptionService.js';
+export * from './ApiKeyService.js';

package/dist/esm/type/Agent.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/AgentConversation.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/AgentConversationCreateInput.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/AgentConversationCreateMessageInput.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/AgentCreateInput.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/AgentMessage.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/AgentMessageCreateInput.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/AgentResponse.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/AgentSearchInput.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/AgentSortInput.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/AgentUpdateInput.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/BaseProduct.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/BaseProductCategoryRelationship.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/BaseProductClusterRelationship.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/BaseProductSearchInput.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/BaseProductsResponse.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/BatchMetricsFailedJob.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/BatchMetricsFailedJobsByQueue.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/BatchMetricsFailedJobsResponse.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/BatchMetricsHourlyBucket.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/type/BatchMetricsQueueStatusResponse.js

@@ -0,0 +1 @@
+export {};