@salesforce/lds-adapters-platform-content-taxonomy 1.260.0 → 1.261.0

package/dist/es/es2018/platform-content-taxonomy.js

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$3, typeCheckConfig as typeCheckConfig$5, StoreKeyMap, createResourceParams as createResourceParams$5 } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$3, typeCheckConfig as typeCheckConfig$6, StoreKeyMap, createResourceParams as createResourceParams$6 } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys, create: ObjectCreate } = Object;
@@ -408,14 +408,14 @@ function validate$1(obj, path = 'ContentTaxonomyTermRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$1 = 'ContentTaxonomyTermRepresentation';
-function keyBuilder$6(luvio, config) {
+function keyBuilder$7(luvio, config) {
     return keyPrefix + '::' + RepresentationType$1 + ':' + config.id;
 }
 function keyBuilderFromType(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$6(luvio, keyParams);
+    return keyBuilder$7(luvio, keyParams);
 }
 function normalize$1(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -534,15 +534,15 @@ function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
 function select$4(luvio, params) {
     return select$5();
 }
-function keyBuilder$5(luvio, params) {
+function keyBuilder$6(luvio, params) {
     return keyPrefix + '::ContentTaxonomyTermCollectionRepresentation:(' + 'depth:' + params.queryParams.depth + ',' + 'includeMetadata:' + params.queryParams.includeMetadata + ',' + 'includePaths:' + params.queryParams.includePaths + ',' + 'initialTerms:' + params.queryParams.initialTerms + ',' + 'taxonomyId:' + params.queryParams.taxonomyId + ')';
 }
-function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$5(luvio, resourceParams));
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$6(luvio, resourceParams));
 }
 function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$5(luvio, resourceParams);
+    const key = keyBuilder$6(luvio, resourceParams);
     luvio.storeIngest(key, ingest, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -558,7 +558,7 @@ function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$2(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$5(luvio, params);
+    const key = keyBuilder$6(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL,
@@ -569,7 +569,7 @@ function ingestError$2(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$4(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v60.0',
@@ -583,7 +583,7 @@ function createResourceRequest$4(config) {
     };
 }
 
-const adapterName$4 = 'getTerms';
+const adapterName$5 = 'getTerms';
 const getTerms_ConfigPropertyMetadata = [
     generateParamConfigMetadata('depth', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('includeMetadata', false, 1 /* QueryParameter */, 1 /* Boolean */),
@@ -591,56 +591,56 @@ const getTerms_ConfigPropertyMetadata = [
     generateParamConfigMetadata('initialTerms', false, 1 /* QueryParameter */, 0 /* String */, true),
     generateParamConfigMetadata('taxonomyId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getTerms_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$5(getTerms_ConfigPropertyMetadata);
-function keyBuilder$4(luvio, config) {
-    const resourceParams = createResourceParams$4(config);
-    return keyBuilder$5(luvio, resourceParams);
+const getTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getTerms_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$6(getTerms_ConfigPropertyMetadata);
+function keyBuilder$5(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$6(luvio, resourceParams);
 }
-function typeCheckConfig$4(untrustedConfig) {
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$5(untrustedConfig, config, getTerms_ConfigPropertyMetadata);
+    typeCheckConfig$6(untrustedConfig, config, getTerms_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$4(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$2(luvio, config) {
-    createResourceParams$4(config);
+    createResourceParams$5(config);
     return select$4();
 }
 function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$2(luvio, config, resourceParams, response) {
     const snapshot = ingestError$2(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$4(luvio, config, options) {
-    const resourceParams = createResourceParams$4(config);
-    const request = createResourceRequest$4(resourceParams);
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -648,23 +648,23 @@ function buildNetworkSnapshot$4(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
+    return buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$4(luvio, config),
+        recordId: keyBuilder$5(luvio, config),
         node: adapterFragment$2(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getTermsAdapterFactory = (luvio) => function contentTaxonomy__getTerms(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$4(untrustedConfig, getTerms_ConfigPropertyNames);
+    const config = validateAdapterConfig$5(untrustedConfig, getTerms_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -676,15 +676,15 @@ const getTermsAdapterFactory = (luvio) => function contentTaxonomy__getTerms(unt
 function select$3(luvio, params) {
     return select$5();
 }
-function keyBuilder$3(luvio, params) {
+function keyBuilder$4(luvio, params) {
     return keyPrefix + '::ContentTaxonomyTermCollectionRepresentation:(' + 'includeHierarchyWithDepth:' + params.queryParams.includeHierarchyWithDepth + ',' + 'includeMetadata:' + params.queryParams.includeMetadata + ',' + 'page:' + params.queryParams.page + ',' + 'pageSize:' + params.queryParams.pageSize + ',' + 'queryText:' + params.queryParams.queryText + ',' + 'taxonomyIds:' + params.queryParams.taxonomyIds + ')';
 }
-function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$3(luvio, resourceParams));
+function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$4(luvio, resourceParams));
 }
 function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$3(luvio, resourceParams);
+    const key = keyBuilder$4(luvio, resourceParams);
     luvio.storeIngest(key, ingest, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -700,7 +700,7 @@ function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$1(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$3(luvio, params);
+    const key = keyBuilder$4(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL,
@@ -711,7 +711,7 @@ function ingestError$1(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$3(config) {
+function createResourceRequest$4(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v60.0',
@@ -725,7 +725,7 @@ function createResourceRequest$3(config) {
     };
 }
 
-const adapterName$3 = 'searchTerms';
+const adapterName$4 = 'searchTerms';
 const searchTerms_ConfigPropertyMetadata = [
     generateParamConfigMetadata('includeHierarchyWithDepth', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('includeMetadata', false, 1 /* QueryParameter */, 1 /* Boolean */),
@@ -734,56 +734,56 @@ const searchTerms_ConfigPropertyMetadata = [
     generateParamConfigMetadata('queryText', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('taxonomyIds', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
-const searchTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, searchTerms_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$5(searchTerms_ConfigPropertyMetadata);
-function keyBuilder$2(luvio, config) {
-    const resourceParams = createResourceParams$3(config);
-    return keyBuilder$3(luvio, resourceParams);
+const searchTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, searchTerms_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$6(searchTerms_ConfigPropertyMetadata);
+function keyBuilder$3(luvio, config) {
+    const resourceParams = createResourceParams$4(config);
+    return keyBuilder$4(luvio, resourceParams);
 }
-function typeCheckConfig$3(untrustedConfig) {
+function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$5(untrustedConfig, config, searchTerms_ConfigPropertyMetadata);
+    typeCheckConfig$6(untrustedConfig, config, searchTerms_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$3(untrustedConfig);
+    const config = typeCheckConfig$4(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$1(luvio, config) {
-    createResourceParams$3(config);
+    createResourceParams$4(config);
     return select$3();
 }
 function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$1(luvio, config, resourceParams, response) {
     const snapshot = ingestError$1(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$3(luvio, config, options) {
-    const resourceParams = createResourceParams$3(config);
-    const request = createResourceRequest$3(resourceParams);
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -791,23 +791,23 @@ function buildNetworkSnapshot$3(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
+    return buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$2(luvio, config),
+        recordId: keyBuilder$3(luvio, config),
         node: adapterFragment$1(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const searchTermsAdapterFactory = (luvio) => function contentTaxonomy__searchTerms(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$3(untrustedConfig, searchTerms_ConfigPropertyNames);
+    const config = validateAdapterConfig$4(untrustedConfig, searchTerms_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -819,7 +819,7 @@ const searchTermsAdapterFactory = (luvio) => function contentTaxonomy__searchTer
 function select$2(luvio, params) {
     return select$6();
 }
-function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$1(storeKeyMap, luvio, response);
 }
 function ingestSuccess$2(luvio, resourceParams, response) {
@@ -839,7 +839,7 @@ function ingestSuccess$2(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$2(config) {
+function createResourceRequest$3(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v60.0',
@@ -853,36 +853,36 @@ function createResourceRequest$2(config) {
     };
 }
 
-const adapterName$2 = 'createTerm';
+const adapterName$3 = 'createTerm';
 const createTerm_ConfigPropertyMetadata = [
     generateParamConfigMetadata('taxonomyId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('description', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('label', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('parentTermId', true, 2 /* Body */, 0 /* String */),
 ];
-const createTerm_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, createTerm_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$5(createTerm_ConfigPropertyMetadata);
-function typeCheckConfig$2(untrustedConfig) {
+const createTerm_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, createTerm_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$6(createTerm_ConfigPropertyMetadata);
+function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$5(untrustedConfig, config, createTerm_ConfigPropertyMetadata);
+    typeCheckConfig$6(untrustedConfig, config, createTerm_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$2(untrustedConfig);
+    const config = typeCheckConfig$3(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$2(luvio, config, options) {
-    const resourceParams = createResourceParams$2(config);
-    const request = createResourceRequest$2(resourceParams);
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
@@ -890,7 +890,7 @@ function buildNetworkSnapshot$2(luvio, config, options) {
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -900,11 +900,98 @@ function buildNetworkSnapshot$2(luvio, config, options) {
 }
 const createTermAdapterFactory = (luvio) => {
     return function createTerm(untrustedConfig) {
-        const config = validateAdapterConfig$2(untrustedConfig, createTerm_ConfigPropertyNames);
+        const config = validateAdapterConfig$3(untrustedConfig, createTerm_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createTerm"');
         }
+        return buildNetworkSnapshot$3(luvio, config);
+    };
+};
+
+function keyBuilder$2(luvio, params) {
+    return keyBuilder$7(luvio, {
+        id: params.urlParams.termId
+    });
+}
+function getResponseCacheKeys$2(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$2(luvio, resourceParams);
+    cacheKeyMap.set(key, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+}
+function evictSuccess(luvio, resourceParams) {
+    const key = keyBuilder$2(luvio, resourceParams);
+    luvio.storeEvict(key);
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v60.0',
+        basePath: '/connect/content-taxonomy/' + config.urlParams.taxonomyId + '/terms/' + config.urlParams.termId + '',
+        method: 'delete',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$2 = 'deleteTerm';
+const deleteTerm_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('taxonomyId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('termId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('deleteChildren', false, 1 /* QueryParameter */, 1 /* Boolean */),
+    generateParamConfigMetadata('newParentTerm', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const deleteTerm_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, deleteTerm_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$6(deleteTerm_ConfigPropertyMetadata);
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$6(untrustedConfig, config, deleteTerm_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$2(cache, luvio, resourceParams);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const deleteTermAdapterFactory = (luvio) => {
+    return function contentTaxonomydeleteTerm(untrustedConfig) {
+        const config = validateAdapterConfig$2(untrustedConfig, deleteTerm_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName$2}"`);
+        }
         return buildNetworkSnapshot$2(luvio, config);
     };
 };
@@ -913,7 +1000,7 @@ function select$1(luvio, params) {
     return select$6();
 }
 function keyBuilder$1(luvio, params) {
-    return keyBuilder$6(luvio, {
+    return keyBuilder$7(luvio, {
         id: params.urlParams.termId
     });
 }
@@ -969,14 +1056,14 @@ const getTerm_ConfigPropertyMetadata = [
     generateParamConfigMetadata('termId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getTerm_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getTerm_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$5(getTerm_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$6(getTerm_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams$1(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    typeCheckConfig$5(untrustedConfig, config, getTerm_ConfigPropertyMetadata);
+    typeCheckConfig$6(untrustedConfig, config, getTerm_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
@@ -1096,10 +1183,10 @@ const updateTerm_ConfigPropertyMetadata = [
     generateParamConfigMetadata('parentTermId', true, 2 /* Body */, 0 /* String */),
 ];
 const updateTerm_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, updateTerm_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$5(updateTerm_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$6(updateTerm_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$5(untrustedConfig, config, updateTerm_ConfigPropertyMetadata);
+    typeCheckConfig$6(untrustedConfig, config, updateTerm_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -1144,4 +1231,4 @@ const updateTermAdapterFactory = (luvio) => {
     };
 };
 
-export { createTermAdapterFactory, getTermAdapterFactory, getTermsAdapterFactory, searchTermsAdapterFactory, updateTermAdapterFactory };
+export { createTermAdapterFactory, deleteTermAdapterFactory, getTermAdapterFactory, getTermsAdapterFactory, searchTermsAdapterFactory, updateTermAdapterFactory };

package/dist/es/es2018/types/src/generated/adapters/deleteTerm.d.ts

@@ -0,0 +1,17 @@
+import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, DeleteAdapterFactory as $64$luvio_engine_DeleteAdapterFactory } from '@luvio/engine';
+import { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from './adapter-utils';
+import { ResourceRequestConfig as resources_deleteConnectContentTaxonomyTermsByTaxonomyIdAndTermId_ResourceRequestConfig } from '../resources/deleteConnectContentTaxonomyTermsByTaxonomyIdAndTermId';
+export declare const adapterName = "deleteTerm";
+export declare const deleteTerm_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const deleteTerm_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface DeleteTermConfig {
+    taxonomyId: string;
+    termId: string;
+    deleteChildren?: boolean;
+    newParentTerm?: string;
+}
+export declare const createResourceParams: (config: DeleteTermConfig) => resources_deleteConnectContentTaxonomyTermsByTaxonomyIdAndTermId_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<DeleteTermConfig>): adapter$45$utils_Untrusted<DeleteTermConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): DeleteTermConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: DeleteTermConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<void>;
+export declare const deleteTermAdapterFactory: $64$luvio_engine_DeleteAdapterFactory<DeleteTermConfig>;

package/dist/es/es2018/types/src/generated/artifacts/main.d.ts

@@ -1,5 +1,6 @@
 export { getTermsAdapterFactory } from '../adapters/getTerms';
 export { searchTermsAdapterFactory } from '../adapters/searchTerms';
 export { createTermAdapterFactory } from '../adapters/createTerm';
+export { deleteTermAdapterFactory } from '../adapters/deleteTerm';
 export { getTermAdapterFactory } from '../adapters/getTerm';
 export { updateTermAdapterFactory } from '../adapters/updateTerm';

package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts

@@ -1,4 +1,5 @@
 declare let createTerm: any;
+declare let deleteTerm: any;
 declare let getTerm: any;
 declare let getTermNotifyChange: any;
 declare let getTerms: any;
@@ -7,4 +8,4 @@ declare let updateTerm: any;
 declare let getTerm_imperative: any;
 declare let getTerms_imperative: any;
 declare let searchTerms_imperative: any;
-export { createTerm, getTerm, getTermNotifyChange, getTerms, searchTerms, updateTerm, getTerm_imperative, getTerms_imperative, searchTerms_imperative };
+export { createTerm, deleteTerm, getTerm, getTermNotifyChange, getTerms, searchTerms, updateTerm, getTerm_imperative, getTerms_imperative, searchTerms_imperative };

package/dist/es/es2018/types/src/generated/resources/deleteConnectContentTaxonomyTermsByTaxonomyIdAndTermId.d.ts

@@ -12,5 +12,6 @@ export interface ResourceRequestConfig {
 export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
 export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_NormalizedKeyMetadata;
 export declare function getResponseCacheKeys(cacheKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig): void;
+export declare function evictSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig): void;
 export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
 export default createResourceRequest;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-adapters-platform-content-taxonomy",
-    "version": "1.260.0",
+    "version": "1.261.0",
     "description": "Wire adapters for content taxonomy APIs",
     "license": "SEE LICENSE IN LICENSE.txt",
     "main": "dist/es/es2018/platform-content-taxonomy.js",
@@ -40,10 +40,10 @@
         "test:unit": "jest"
     },
     "dependencies": {
-        "@salesforce/lds-bindings": "^1.260.0"
+        "@salesforce/lds-bindings": "^1.261.0"
     },
     "devDependencies": {
-        "@salesforce/lds-compiler-plugins": "^1.260.0"
+        "@salesforce/lds-compiler-plugins": "^1.261.0"
     },
     "nx": {
         "targets": {

package/sfdc/index.js

@@ -14,7 +14,7 @@
 /* proxy-compat-disable */
 import { createInstrumentedAdapter, createLDSAdapter, createWireAdapterConstructor, createImperativeAdapter } from 'force/ldsBindings';
 import { withDefaultLuvio } from 'force/ldsEngine';
-import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$5, typeCheckConfig as typeCheckConfig$5, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$3 } from 'force/luvioEngine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$6, typeCheckConfig as typeCheckConfig$6, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$3 } from 'force/luvioEngine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys, create: ObjectCreate } = Object;
@@ -418,14 +418,14 @@ function validate$1(obj, path = 'ContentTaxonomyTermRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$1 = 'ContentTaxonomyTermRepresentation';
-function keyBuilder$6(luvio, config) {
+function keyBuilder$7(luvio, config) {
     return keyPrefix + '::' + RepresentationType$1 + ':' + config.id;
 }
 function keyBuilderFromType(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$6(luvio, keyParams);
+    return keyBuilder$7(luvio, keyParams);
 }
 function normalize$1(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -469,7 +469,7 @@ function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
 function select$5(luvio, params) {
     return select$6();
 }
-function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$1(storeKeyMap, luvio, response);
 }
 function ingestSuccess$4(luvio, resourceParams, response) {
@@ -489,7 +489,7 @@ function ingestSuccess$4(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$4(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v60.0',
@@ -503,36 +503,36 @@ function createResourceRequest$4(config) {
     };
 }
 
-const adapterName$4 = 'createTerm';
+const adapterName$5 = 'createTerm';
 const createTerm_ConfigPropertyMetadata = [
     generateParamConfigMetadata('taxonomyId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('description', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('label', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('parentTermId', true, 2 /* Body */, 0 /* String */),
 ];
-const createTerm_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, createTerm_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$5(createTerm_ConfigPropertyMetadata);
-function typeCheckConfig$4(untrustedConfig) {
+const createTerm_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, createTerm_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$6(createTerm_ConfigPropertyMetadata);
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$5(untrustedConfig, config, createTerm_ConfigPropertyMetadata);
+    typeCheckConfig$6(untrustedConfig, config, createTerm_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$4(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$4(luvio, config, options) {
-    const resourceParams = createResourceParams$4(config);
-    const request = createResourceRequest$4(resourceParams);
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
@@ -540,7 +540,7 @@ function buildNetworkSnapshot$4(luvio, config, options) {
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -550,11 +550,98 @@ function buildNetworkSnapshot$4(luvio, config, options) {
 }
 const createTermAdapterFactory = (luvio) => {
     return function createTerm(untrustedConfig) {
-        const config = validateAdapterConfig$4(untrustedConfig, createTerm_ConfigPropertyNames);
+        const config = validateAdapterConfig$5(untrustedConfig, createTerm_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createTerm"');
         }
+        return buildNetworkSnapshot$5(luvio, config);
+    };
+};
+
+function keyBuilder$6(luvio, params) {
+    return keyBuilder$7(luvio, {
+        id: params.urlParams.termId
+    });
+}
+function getResponseCacheKeys$4(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$6(luvio, resourceParams);
+    cacheKeyMap.set(key, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+}
+function evictSuccess(luvio, resourceParams) {
+    const key = keyBuilder$6(luvio, resourceParams);
+    luvio.storeEvict(key);
+}
+function createResourceRequest$4(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v60.0',
+        basePath: '/connect/content-taxonomy/' + config.urlParams.taxonomyId + '/terms/' + config.urlParams.termId + '',
+        method: 'delete',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$4 = 'deleteTerm';
+const deleteTerm_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('taxonomyId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('termId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('deleteChildren', false, 1 /* QueryParameter */, 1 /* Boolean */),
+    generateParamConfigMetadata('newParentTerm', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const deleteTerm_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, deleteTerm_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$6(deleteTerm_ConfigPropertyMetadata);
+function typeCheckConfig$4(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$6(untrustedConfig, config, deleteTerm_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$4(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$4(cache, luvio, resourceParams);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const deleteTermAdapterFactory = (luvio) => {
+    return function contentTaxonomydeleteTerm(untrustedConfig) {
+        const config = validateAdapterConfig$4(untrustedConfig, deleteTerm_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName$4}"`);
+        }
         return buildNetworkSnapshot$4(luvio, config);
     };
 };
@@ -563,7 +650,7 @@ function select$4(luvio, params) {
     return select$6();
 }
 function keyBuilder$5(luvio, params) {
-    return keyBuilder$6(luvio, {
+    return keyBuilder$7(luvio, {
         id: params.urlParams.termId
     });
 }
@@ -626,14 +713,14 @@ const getTerm_ConfigPropertyMetadata = [
     generateParamConfigMetadata('termId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getTerm_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getTerm_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$5(getTerm_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$6(getTerm_ConfigPropertyMetadata);
 function keyBuilder$4(luvio, config) {
     const resourceParams = createResourceParams$3(config);
     return keyBuilder$5(luvio, resourceParams);
 }
 function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$5(untrustedConfig, config, getTerm_ConfigPropertyMetadata);
+    typeCheckConfig$6(untrustedConfig, config, getTerm_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
@@ -708,7 +795,7 @@ const getTermAdapterFactory = (luvio) => function contentTaxonomy__getTerm(untru
 };
 const notifyChangeFactory = (luvio, options) => {
     return function getConnectContentTaxonomyTermsByTaxonomyIdAndTermIdNotifyChange(configs) {
-        const keys = configs.map(c => keyBuilder$6(luvio, c));
+        const keys = configs.map(c => keyBuilder$7(luvio, c));
         luvio.getNotifyChangeStoreEntries(keys).then(entries => {
             for (let i = 0, len = entries.length; i < len; i++) {
                 const { key, record: val } = entries[i];
@@ -877,14 +964,14 @@ const getTerms_ConfigPropertyMetadata = [
     generateParamConfigMetadata('taxonomyId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getTerms_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$5(getTerms_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$6(getTerms_ConfigPropertyMetadata);
 function keyBuilder$2(luvio, config) {
     const resourceParams = createResourceParams$2(config);
     return keyBuilder$3(luvio, resourceParams);
 }
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$5(untrustedConfig, config, getTerms_ConfigPropertyMetadata);
+    typeCheckConfig$6(untrustedConfig, config, getTerms_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
@@ -1020,14 +1107,14 @@ const searchTerms_ConfigPropertyMetadata = [
     generateParamConfigMetadata('taxonomyIds', false, 1 /* QueryParameter */, 0 /* String */, true),
 ];
 const searchTerms_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, searchTerms_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$5(searchTerms_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$6(searchTerms_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams$1(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    typeCheckConfig$5(untrustedConfig, config, searchTerms_ConfigPropertyMetadata);
+    typeCheckConfig$6(untrustedConfig, config, searchTerms_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
@@ -1147,10 +1234,10 @@ const updateTerm_ConfigPropertyMetadata = [
     generateParamConfigMetadata('parentTermId', true, 2 /* Body */, 0 /* String */),
 ];
 const updateTerm_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, updateTerm_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$5(updateTerm_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$6(updateTerm_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$5(untrustedConfig, config, updateTerm_ConfigPropertyMetadata);
+    typeCheckConfig$6(untrustedConfig, config, updateTerm_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -1196,6 +1283,7 @@ const updateTermAdapterFactory = (luvio) => {
 };
 
 let createTerm;
+let deleteTerm;
 let getTerm;
 let getTermNotifyChange;
 let getTerms;
@@ -1208,6 +1296,7 @@ let searchTerms_imperative;
 const getTermMetadata = { apiFamily: 'contenttaxonomy', name: 'getTerm', ttl: 100 };
 const getTermsMetadata = { apiFamily: 'contenttaxonomy', name: 'getTerms', ttl: 100 };
 const searchTermsMetadata = { apiFamily: 'contenttaxonomy', name: 'searchTerms', ttl: 100 };
+// Notify Update Available
 function bindExportsTo(luvio) {
     // LDS Adapters
     const getTerm_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getTerm', getTermAdapterFactory), getTermMetadata);
@@ -1219,6 +1308,7 @@ function bindExportsTo(luvio) {
     }
     return {
         createTerm: unwrapSnapshotData(createTermAdapterFactory),
+        deleteTerm: createLDSAdapter(luvio, adapterName$4, deleteTermAdapterFactory),
         getTerm: createWireAdapterConstructor(luvio, getTerm_ldsAdapter, getTermMetadata),
         getTermNotifyChange: createLDSAdapter(luvio, 'getTermNotifyChange', notifyChangeFactory),
         getTerms: createWireAdapterConstructor(luvio, getTerms_ldsAdapter, getTermsMetadata),
@@ -1227,12 +1317,14 @@ function bindExportsTo(luvio) {
         // Imperative GET Adapters
         getTerm_imperative: createImperativeAdapter(luvio, getTerm_ldsAdapter, getTermMetadata),
         getTerms_imperative: createImperativeAdapter(luvio, getTerms_ldsAdapter, getTermsMetadata),
-        searchTerms_imperative: createImperativeAdapter(luvio, searchTerms_ldsAdapter, searchTermsMetadata)
+        searchTerms_imperative: createImperativeAdapter(luvio, searchTerms_ldsAdapter, searchTermsMetadata),
+        // Notify Update Availables
     };
 }
 withDefaultLuvio((luvio) => {
     ({
         createTerm,
+        deleteTerm,
         getTerm,
         getTermNotifyChange,
         getTerms,
@@ -1240,9 +1332,9 @@ withDefaultLuvio((luvio) => {
         updateTerm,
         getTerm_imperative,
         getTerms_imperative,
-        searchTerms_imperative
+        searchTerms_imperative,
     } = bindExportsTo(luvio));
 });
 
-export { createTerm, getTerm, getTermNotifyChange, getTerm_imperative, getTerms, getTerms_imperative, searchTerms, searchTerms_imperative, updateTerm };
-// version: 1.260.0-7a5d1675a
+export { createTerm, deleteTerm, getTerm, getTermNotifyChange, getTerm_imperative, getTerms, getTerms_imperative, searchTerms, searchTerms_imperative, updateTerm };
+// version: 1.261.0-10ee630e7

package/src/raml/luvio.raml

@@ -38,6 +38,11 @@ types:
       (luvio.adapter):
         name: searchTerms
   /{taxonomyId}/terms/{termId}:
+    delete:
+      (luvio.adapter):
+        name: deleteTerm
+      (luvio.key):
+        id: urlParams.termId
     get:
       (luvio.adapter):
         name: getTerm