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

package/dist/esm/service/AgentService.js

@@ -0,0 +1,77 @@
+import { runOperation } from './runOperation.js';
+import { document as agentDoc } from '../generated/operations/agent.js';
+import { document as agentConversationCreateDoc } from '../generated/operations/agentConversationCreate.js';
+import { document as agentCreateDoc } from '../generated/operations/agentCreate.js';
+import { document as agentDeleteDoc } from '../generated/operations/agentDelete.js';
+import { document as agentMessageCreateDoc } from '../generated/operations/agentMessageCreate.js';
+import { document as agentUpdateDoc } from '../generated/operations/agentUpdate.js';
+import { document as agentsDoc } from '../generated/operations/agents.js';
+/**
+ Service for Agent-related GraphQL operations
+ */
+export function agentService(client) {
+    return {
+        /**
+           Retrieve a single agent by its unique identifier.
+           */
+        async getAgent(variables) {
+            const result = await runOperation(client, agentDoc, 'agent', { ...variables });
+            return result.data.agent;
+        },
+        /**
+           Start a new conversation with an agent.
+           */
+        async agentConversationCreate(variables) {
+            const result = await runOperation(client, agentConversationCreateDoc, 'agentConversationCreate', { ...variables });
+            return result.data.agentConversationCreate;
+        },
+        /**
+           Create a new agent with the specified configuration.
+           */
+        async agentCreate(variables) {
+            const result = await runOperation(client, agentCreateDoc, 'agentCreate', { ...variables });
+            return result.data.agentCreate;
+        },
+        /**
+           Delete an agent by its unique identifier.
+           */
+        async agentDelete(variables) {
+            const result = await runOperation(client, agentDeleteDoc, 'agentDelete', { ...variables });
+            return result.data.agentDelete;
+        },
+        /**
+           Send a message to an agent.
+           */
+        async agentMessageCreate(variables) {
+            const result = await runOperation(client, agentMessageCreateDoc, 'agentMessageCreate', { ...variables });
+            return result.data.agentMessageCreate;
+        },
+        /**
+           Update an existing agent's configuration.
+           */
+        async agentUpdate(variables) {
+            const result = await runOperation(client, agentUpdateDoc, 'agentUpdate', { ...variables });
+            return result.data.agentUpdate;
+        },
+        /**
+           Search and retrieve agents with filtering and pagination.
+           */
+        async getAgents(variables) {
+            const result = await runOperation(client, agentsDoc, 'agents', { ...variables });
+            return result.data.agents;
+        },
+    };
+}
+/**
+ * Backwards-compatible class form. New code should call `agentService(client)`.
+ */
+export class AgentService {
+    constructor(client) { this._svc = agentService(client); }
+    getAgent(variables) { return this._svc.getAgent(variables); }
+    agentConversationCreate(variables) { return this._svc.agentConversationCreate(variables); }
+    agentCreate(variables) { return this._svc.agentCreate(variables); }
+    agentDelete(variables) { return this._svc.agentDelete(variables); }
+    agentMessageCreate(variables) { return this._svc.agentMessageCreate(variables); }
+    agentUpdate(variables) { return this._svc.agentUpdate(variables); }
+    getAgents(variables) { return this._svc.getAgents(variables); }
+}

package/dist/esm/service/ApiKeyService.js

@@ -0,0 +1,104 @@
+import { runOperation } from './runOperation.js';
+import { document as gqlApiKeyDoc } from '../generated/operations/gqlApiKey.js';
+import { document as gqlApiKeyCreateDoc } from '../generated/operations/gqlApiKeyCreate.js';
+import { document as gqlApiKeyDeleteDoc } from '../generated/operations/gqlApiKeyDelete.js';
+import { document as gqlApiKeyUpdateDoc } from '../generated/operations/gqlApiKeyUpdate.js';
+import { document as gqlApiKeysDoc } from '../generated/operations/gqlApiKeys.js';
+import { document as restApiKeyDoc } from '../generated/operations/restApiKey.js';
+import { document as restApiKeyCreateDoc } from '../generated/operations/restApiKeyCreate.js';
+import { document as restApiKeyDeleteDoc } from '../generated/operations/restApiKeyDelete.js';
+import { document as restApiKeyUpdateDoc } from '../generated/operations/restApiKeyUpdate.js';
+import { document as restApiKeysDoc } from '../generated/operations/restApiKeys.js';
+/**
+ Service for ApiKey-related GraphQL operations
+ */
+export function apiKeyService(client) {
+    return {
+        /**
+           Retrieves a specific GraphQL API key by its unique identifier.
+           */
+        async getGqlApiKey(variables) {
+            const result = await runOperation(client, gqlApiKeyDoc, 'gqlApiKey', { ...variables });
+            return result.data.gqlApiKey;
+        },
+        /**
+           Creates a new GraphQL API key.
+           */
+        async gqlApiKeyCreate(variables) {
+            const result = await runOperation(client, gqlApiKeyCreateDoc, 'gqlApiKeyCreate', { ...variables });
+            return result.data.gqlApiKeyCreate;
+        },
+        /**
+           Permanently deletes a GraphQL API key from the system.
+           */
+        async gqlApiKeyDelete(variables) {
+            const result = await runOperation(client, gqlApiKeyDeleteDoc, 'gqlApiKeyDelete', { ...variables });
+            return result.data.gqlApiKeyDelete;
+        },
+        /**
+           Updates an existing GraphQL API key.
+           */
+        async gqlApiKeyUpdate(variables) {
+            const result = await runOperation(client, gqlApiKeyUpdateDoc, 'gqlApiKeyUpdate', { ...variables });
+            return result.data.gqlApiKeyUpdate;
+        },
+        /**
+           Searches and retrieves GraphQL API keys based on filter criteria.
+           */
+        async getGqlApiKeys(variables) {
+            const result = await runOperation(client, gqlApiKeysDoc, 'gqlApiKeys', { ...variables });
+            return result.data.gqlApiKeys;
+        },
+        /**
+           Retrieves a specific REST API key by its unique identifier.
+           */
+        async getRestApiKey(variables) {
+            const result = await runOperation(client, restApiKeyDoc, 'restApiKey', { ...variables });
+            return result.data.restApiKey;
+        },
+        /**
+           Creates a new REST API key.
+           */
+        async restApiKeyCreate(variables) {
+            const result = await runOperation(client, restApiKeyCreateDoc, 'restApiKeyCreate', { ...variables });
+            return result.data.restApiKeyCreate;
+        },
+        /**
+           Permanently deletes a REST API key from the system.
+           */
+        async restApiKeyDelete(variables) {
+            const result = await runOperation(client, restApiKeyDeleteDoc, 'restApiKeyDelete', { ...variables });
+            return result.data.restApiKeyDelete;
+        },
+        /**
+           Updates an existing REST API key.
+           */
+        async restApiKeyUpdate(variables) {
+            const result = await runOperation(client, restApiKeyUpdateDoc, 'restApiKeyUpdate', { ...variables });
+            return result.data.restApiKeyUpdate;
+        },
+        /**
+           Searches and retrieves REST API keys based on filter criteria.
+           */
+        async getRestApiKeys(variables) {
+            const result = await runOperation(client, restApiKeysDoc, 'restApiKeys', { ...variables });
+            return result.data.restApiKeys;
+        },
+    };
+}
+/**
+ * Backwards-compatible class form. New code should call `apiKeyService(client)`.
+ */
+export class ApiKeyService {
+    constructor(client) { this._svc = apiKeyService(client); }
+    getGqlApiKey(variables) { return this._svc.getGqlApiKey(variables); }
+    gqlApiKeyCreate(variables) { return this._svc.gqlApiKeyCreate(variables); }
+    gqlApiKeyDelete(variables) { return this._svc.gqlApiKeyDelete(variables); }
+    gqlApiKeyUpdate(variables) { return this._svc.gqlApiKeyUpdate(variables); }
+    getGqlApiKeys(variables) { return this._svc.getGqlApiKeys(variables); }
+    getRestApiKey(variables) { return this._svc.getRestApiKey(variables); }
+    restApiKeyCreate(variables) { return this._svc.restApiKeyCreate(variables); }
+    restApiKeyDelete(variables) { return this._svc.restApiKeyDelete(variables); }
+    restApiKeyUpdate(variables) { return this._svc.restApiKeyUpdate(variables); }
+    getRestApiKeys(variables) { return this._svc.getRestApiKeys(variables); }
+}

package/dist/esm/service/CategoryService.js

@@ -1,3 +1,9 @@
+import { document as categoryBySlugDoc } from '../generated/operations/categoryBySlug.js';
+import { document as categoryBySourceDoc } from '../generated/operations/categoryBySource.js';
+import { document as categoryChildrenDoc } from '../generated/operations/categoryChildren.js';
+import { document as categoryHierarchyDoc } from '../generated/operations/categoryHierarchy.js';
+import { document as categoryMoveAboveDoc } from '../generated/operations/categoryMoveAbove.js';
+import { document as categoryMoveBelowDoc } from '../generated/operations/categoryMoveBelow.js';
 import { runOperation } from './runOperation.js';
 import { document as categoriesDoc } from '../generated/operations/categories.js';
 import { document as categoryDoc } from '../generated/operations/category.js';
@@ -97,6 +103,48 @@ export function categoryService(client) {
             const result = await runOperation(client, attributeResultByCategoryIdDoc, 'attributeResultByCategoryId', { categoryId, input });
             return result.data.attributeResultByCategoryId;
         },
+        /**
+           Retrieve a single category by localized slug and language.
+           */
+        async getCategoryBySlug(variables) {
+            const result = await runOperation(client, categoryBySlugDoc, 'categoryBySlug', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.categoryBySlug;
+        },
+        /**
+           Retrieve a single category by its external source / source identifier pair.
+           */
+        async getCategoryBySource(variables) {
+            const result = await runOperation(client, categoryBySourceDoc, 'categoryBySource', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.categoryBySource;
+        },
+        /**
+           Retrieve the direct child categories of a category.
+           */
+        async getCategoryChildren(variables) {
+            const result = await runOperation(client, categoryChildrenDoc, 'categoryChildren', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.categoryChildren;
+        },
+        /**
+           Retrieve the ancestor chain of a category, ordered from the category itself up to the root.
+           */
+        async getCategoryHierarchy(variables) {
+            const result = await runOperation(client, categoryHierarchyDoc, 'categoryHierarchy', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.categoryHierarchy;
+        },
+        /**
+           Reorder a category so it appears immediately before another category within the same parent.
+           */
+        async categoryMoveAbove(variables) {
+            const result = await runOperation(client, categoryMoveAboveDoc, 'categoryMoveAbove', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.categoryMoveAbove;
+        },
+        /**
+           Reorder a category so it appears immediately after another category within the same parent.
+           */
+        async categoryMoveBelow(variables) {
+            const result = await runOperation(client, categoryMoveBelowDoc, 'categoryMoveBelow', { ...variables, language: variables.language ?? client.getDefaultLanguage() });
+            return result.data.categoryMoveBelow;
+        },
     };
 }
 /**
@@ -146,4 +194,10 @@ export class CategoryService {
      * @param input Attribute result search input
      */
     getAttributeResultByCategoryId(categoryId, input) { return this._svc.getAttributeResultByCategoryId(categoryId, input); }
+    getCategoryBySlug(variables) { return this._svc.getCategoryBySlug(variables); }
+    getCategoryBySource(variables) { return this._svc.getCategoryBySource(variables); }
+    getCategoryChildren(variables) { return this._svc.getCategoryChildren(variables); }
+    getCategoryHierarchy(variables) { return this._svc.getCategoryHierarchy(variables); }
+    categoryMoveAbove(variables) { return this._svc.categoryMoveAbove(variables); }
+    categoryMoveBelow(variables) { return this._svc.categoryMoveBelow(variables); }
 }

package/dist/esm/service/ClusterConfigService.js

@@ -1,3 +1,9 @@
+import { document as clusterConfigSettingDoc } from '../generated/operations/clusterConfigSetting.js';
+import { document as clusterConfigSettingCreateDoc } from '../generated/operations/clusterConfigSettingCreate.js';
+import { document as clusterConfigSettingDeleteDoc } from '../generated/operations/clusterConfigSettingDelete.js';
+import { document as clusterConfigSettingUpdateDoc } from '../generated/operations/clusterConfigSettingUpdate.js';
+import { document as clusterConfigUpdateDoc } from '../generated/operations/clusterConfigUpdate.js';
+import { document as clusterConfigsPaginatedDoc } from '../generated/operations/clusterConfigsPaginated.js';
 import { runOperation } from './runOperation.js';
 import { document as clusterConfigDoc } from '../generated/operations/clusterConfig.js';
 import { document as clusterConfigsDoc } from '../generated/operations/clusterConfigs.js';
@@ -45,6 +51,48 @@ export function clusterConfigService(client) {
             const result = await runOperation(client, clusterConfigUpdateSettingDoc, 'clusterConfigUpdateSetting', { clusterConfigId, settingId, input });
             return result.data.clusterConfigUpdateSetting;
         },
+        /**
+           Retrieve a single cluster configuration setting by global identifier.
+           */
+        async getClusterConfigSetting(variables) {
+            const result = await runOperation(client, clusterConfigSettingDoc, 'clusterConfigSetting', { ...variables });
+            return result.data.clusterConfigSetting;
+        },
+        /**
+           Create a new setting on the cluster configuration identified by the supplied global identifier.
+           */
+        async clusterConfigSettingCreate(variables) {
+            const result = await runOperation(client, clusterConfigSettingCreateDoc, 'clusterConfigSettingCreate', { ...variables });
+            return result.data.clusterConfigSettingCreate;
+        },
+        /**
+           Remove a cluster configuration setting identified by global identifier.
+           */
+        async clusterConfigSettingDelete(variables) {
+            const result = await runOperation(client, clusterConfigSettingDeleteDoc, 'clusterConfigSettingDelete', { ...variables });
+            return result.data.clusterConfigSettingDelete;
+        },
+        /**
+           Apply a partial update to a cluster configuration setting identified by global identifier.
+           */
+        async clusterConfigSettingUpdate(variables) {
+            const result = await runOperation(client, clusterConfigSettingUpdateDoc, 'clusterConfigSettingUpdate', { ...variables });
+            return result.data.clusterConfigSettingUpdate;
+        },
+        /**
+           Apply a partial update to an existing cluster configuration.
+           */
+        async clusterConfigUpdate(variables) {
+            const result = await runOperation(client, clusterConfigUpdateDoc, 'clusterConfigUpdate', { ...variables });
+            return result.data.clusterConfigUpdate;
+        },
+        /**
+           Search cluster configurations with filtering and pagination.
+           */
+        async getClusterConfigsPaginated(variables) {
+            const result = await runOperation(client, clusterConfigsPaginatedDoc, 'clusterConfigsPaginated', { ...variables });
+            return result.data.clusterConfigsPaginated;
+        },
     };
 }
 /**
@@ -73,4 +121,10 @@ export class ClusterConfigService {
      * @param input Cluster config setting update input
      */
     updateClusterConfigSetting(clusterConfigId, settingId, input) { return this._svc.updateClusterConfigSetting(clusterConfigId, settingId, input); }
+    getClusterConfigSetting(variables) { return this._svc.getClusterConfigSetting(variables); }
+    clusterConfigSettingCreate(variables) { return this._svc.clusterConfigSettingCreate(variables); }
+    clusterConfigSettingDelete(variables) { return this._svc.clusterConfigSettingDelete(variables); }
+    clusterConfigSettingUpdate(variables) { return this._svc.clusterConfigSettingUpdate(variables); }
+    clusterConfigUpdate(variables) { return this._svc.clusterConfigUpdate(variables); }
+    getClusterConfigsPaginated(variables) { return this._svc.getClusterConfigsPaginated(variables); }
 }

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); }
 }