npm - @salesforce/lds-adapters-analytics-app-framework - Versions diffs - 1.327.0 → 1.329.0 - Mend

@salesforce/lds-adapters-analytics-app-framework 1.327.0 → 1.329.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/es/es2018/analytics-app-framework.js CHANGED Viewed

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$a, typeCheckConfig as typeCheckConfig$e, StoreKeyMap, createResourceParams as createResourceParams$e } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$a, typeCheckConfig as typeCheckConfig$g, StoreKeyMap, createResourceParams as createResourceParams$g } from '@luvio/engine';
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -157,7 +157,7 @@ function validate$s(obj, path = 'UserRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$C = function UserRepresentationSelect() {
+const select$D = function UserRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$p,
@@ -217,7 +217,7 @@ function validate$r(obj, path = 'ScheduledTimezoneRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$B = function ScheduledTimezoneRepresentationSelect() {
+const select$C = function ScheduledTimezoneRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$o,
@@ -284,8 +284,8 @@ function validate$q(obj, path = 'ScheduledTimeRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$A = function ScheduledTimeRepresentationSelect() {
-    const { selections: ScheduledTimezoneRepresentation__selections, opaque: ScheduledTimezoneRepresentation__opaque, } = select$B();
+const select$B = function ScheduledTimeRepresentationSelect() {
+    const { selections: ScheduledTimezoneRepresentation__selections, opaque: ScheduledTimezoneRepresentation__opaque, } = select$C();
     return {
         kind: 'Fragment',
         version: VERSION$n,
@@ -327,8 +327,8 @@ function equals$k(existing, incoming) {
 }
 const VERSION$m = "91838b86aa135ce828af6242b11ae888";
-const select$z = function HourlyScheduledItemRepresentationSelect() {
-    const { selections: ScheduledItemRepresentationSelections } = select$w();
+const select$A = function HourlyScheduledItemRepresentationSelect() {
+    const { selections: ScheduledItemRepresentationSelections } = select$x();
     return {
         kind: 'Fragment',
         version: VERSION$m,
@@ -349,8 +349,8 @@ const select$z = function HourlyScheduledItemRepresentationSelect() {
 };
 const VERSION$l = "46260a34f0b2c2d7adc7f8c150a8d8fb";
-const select$y = function WeeklyScheduledItemRepresentationSelect() {
-    const { selections: ScheduledItemRepresentationSelections } = select$w();
+const select$z = function WeeklyScheduledItemRepresentationSelect() {
+    const { selections: ScheduledItemRepresentationSelections } = select$x();
     return {
         kind: 'Fragment',
         version: VERSION$l,
@@ -367,8 +367,8 @@ const select$y = function WeeklyScheduledItemRepresentationSelect() {
 };
 const VERSION$k = "dcda6d015a01d9acde5fac241448cfe4";
-const select$x = function DailyScheduledItemRepresentationSelect() {
-    const { selections: ScheduledItemRepresentationSelections } = select$w();
+const select$y = function DailyScheduledItemRepresentationSelect() {
+    const { selections: ScheduledItemRepresentationSelections } = select$x();
     return {
         kind: 'Fragment',
         version: VERSION$k,
@@ -413,9 +413,9 @@ function validate$p(obj, path = 'ScheduledItemRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const selectChildren = function ScheduledItemRepresentationSelectChildren() {
-    const hourlyScheduledItemRepresentationSelections = select$z();
-    const weeklyScheduledItemRepresentationSelections = select$y();
-    const dailyScheduledItemRepresentationSelections = select$x();
+    const hourlyScheduledItemRepresentationSelections = select$A();
+    const weeklyScheduledItemRepresentationSelections = select$z();
+    const dailyScheduledItemRepresentationSelections = select$y();
     return {
         kind: 'Fragment',
         union: true,
@@ -427,8 +427,8 @@ const selectChildren = function ScheduledItemRepresentationSelectChildren() {
         }
     };
 };
-const select$w = function ScheduledItemRepresentationSelect() {
-    const { selections: ScheduledTimeRepresentation__selections, opaque: ScheduledTimeRepresentation__opaque, } = select$A();
+const select$x = function ScheduledItemRepresentationSelect() {
+    const { selections: ScheduledTimeRepresentation__selections, opaque: ScheduledTimeRepresentation__opaque, } = select$B();
     return {
         kind: 'Fragment',
         version: VERSION$j,
@@ -533,7 +533,7 @@ function validate$o(obj, path = 'AppScheduleRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$v = function AppScheduleRepresentationSelect() {
+const select$w = function AppScheduleRepresentationSelect() {
     const ScheduledItemRepresentation__unionSelections = selectChildren();
     return {
         kind: 'Fragment',
@@ -738,21 +738,21 @@ function validate$n(obj, path = 'AppRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$b = 'AppRepresentation';
-function keyBuilder$t(luvio, config) {
+function keyBuilder$u(luvio, config) {
     return keyPrefix + '::' + RepresentationType$b + ':' + config.id;
 }
 function keyBuilderFromType$8(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$t(luvio, keyParams);
+    return keyBuilder$u(luvio, keyParams);
 }
 function normalize$b(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$u = function AppRepresentationSelect() {
-    const { selections: UserRepresentation__selections, opaque: UserRepresentation__opaque, } = select$C();
-    const { selections: AppScheduleRepresentation__selections, opaque: AppScheduleRepresentation__opaque, } = select$v();
+const select$v = function AppRepresentationSelect() {
+    const { selections: UserRepresentation__selections, opaque: UserRepresentation__opaque, } = select$D();
+    const { selections: AppScheduleRepresentation__selections, opaque: AppScheduleRepresentation__opaque, } = select$w();
     return {
         kind: 'Fragment',
         version: VERSION$h,
@@ -1012,7 +1012,7 @@ function normalize$a(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$t = function AppCollectionRepresentationSelect() {
+const select$u = function AppCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$g,
@@ -1022,7 +1022,7 @@ const select$t = function AppCollectionRepresentationSelect() {
                 name: 'apps',
                 kind: 'Link',
                 plural: true,
-                fragment: select$u()
+                fragment: select$v()
             }
         ]
     };
@@ -1066,22 +1066,22 @@ function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$s(luvio, params) {
-    return select$t();
+function select$t(luvio, params) {
+    return select$u();
 }
-function keyBuilder$s(luvio, params) {
+function keyBuilder$t(luvio, params) {
     return keyPrefix + '::AppCollectionRepresentation:(' + 'templateSourceId:' + params.queryParams.templateSourceId + ',' + 'type:' + params.queryParams.type + ')';
 }
-function getResponseCacheKeys$d(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$a(storeKeyMap, luvio, response, () => keyBuilder$s(luvio, resourceParams));
+function getResponseCacheKeys$f(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$a(storeKeyMap, luvio, response, () => keyBuilder$t(luvio, resourceParams));
 }
-function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$d(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$s(luvio, resourceParams);
+    const key = keyBuilder$t(luvio, resourceParams);
     luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$s(),
+        node: select$t(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1093,7 +1093,7 @@ function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$9(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$s(luvio, params);
+    const key = keyBuilder$t(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$a,
@@ -1104,7 +1104,7 @@ function ingestError$9(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$d(config) {
+function createResourceRequest$f(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -1118,61 +1118,61 @@ function createResourceRequest$d(config) {
     };
 }
-const adapterName$d = 'getApps';
+const adapterName$f = 'getApps';
 const getApps_ConfigPropertyMetadata = [
     generateParamConfigMetadata('templateSourceId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('type', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getApps_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, getApps_ConfigPropertyMetadata);
-const createResourceParams$d = /*#__PURE__*/ createResourceParams$e(getApps_ConfigPropertyMetadata);
-function keyBuilder$r(luvio, config) {
-    const resourceParams = createResourceParams$d(config);
-    return keyBuilder$s(luvio, resourceParams);
+const getApps_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, getApps_ConfigPropertyMetadata);
+const createResourceParams$f = /*#__PURE__*/ createResourceParams$g(getApps_ConfigPropertyMetadata);
+function keyBuilder$s(luvio, config) {
+    const resourceParams = createResourceParams$f(config);
+    return keyBuilder$t(luvio, resourceParams);
 }
-function typeCheckConfig$d(untrustedConfig) {
+function typeCheckConfig$f(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, getApps_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getApps_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$d(untrustedConfig);
+    const config = typeCheckConfig$f(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$9(luvio, config) {
-    createResourceParams$d(config);
-    return select$s();
+    createResourceParams$f(config);
+    return select$t();
 }
 function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$c(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$d(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$9(luvio, config, resourceParams, response) {
     const snapshot = ingestError$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$d(luvio, config, options) {
-    const resourceParams = createResourceParams$d(config);
-    const request = createResourceRequest$d(resourceParams);
+function buildNetworkSnapshot$f(luvio, config, options) {
+    const resourceParams = createResourceParams$f(config);
+    const request = createResourceRequest$f(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$d(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$f(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1180,23 +1180,23 @@ function buildNetworkSnapshot$d(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$d, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$f, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$r(luvio, config),
+        recordId: keyBuilder$s(luvio, config),
         node: adapterFragment$9(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getAppsAdapterFactory = (luvio) => function AppFramework__getApps(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$d(untrustedConfig, getApps_ConfigPropertyNames);
+    const config = validateAdapterConfig$f(untrustedConfig, getApps_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -1266,14 +1266,14 @@ function validate$l(obj, path = 'AppResultRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$9 = 'AppResultRepresentation';
-function keyBuilder$q(luvio, config) {
+function keyBuilder$r(luvio, config) {
     return keyPrefix + '::' + RepresentationType$9 + ':' + config.id;
 }
 function keyBuilderFromType$7(luvio, object) {
     const keyParams = {
         id: object.app.id
     };
-    return keyBuilder$q(luvio, keyParams);
+    return keyBuilder$r(luvio, keyParams);
 }
 function normalize$9(input, existing, path, luvio, store, timestamp) {
     const input_app = input.app;
@@ -1290,7 +1290,7 @@ function normalize$9(input, existing, path, luvio, store, timestamp) {
     }, luvio, store, timestamp);
     return input;
 }
-const select$r = function AppResultRepresentationSelect() {
+const select$s = function AppResultRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$f,
@@ -1299,7 +1299,7 @@ const select$r = function AppResultRepresentationSelect() {
             {
                 name: 'app',
                 kind: 'Link',
-                fragment: select$u()
+                fragment: select$v()
             },
             {
                 name: 'failureMessage',
@@ -1368,19 +1368,19 @@ function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
     getTypeCacheKeys$b(rootKeySet, luvio, input.app);
 }
-function select$q(luvio, params) {
-    return select$r();
+function select$r(luvio, params) {
+    return select$s();
 }
-function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$e(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$b(luvio, resourceParams, response) {
+function ingestSuccess$c(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$7(luvio, body);
     luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$q(),
+        node: select$r(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1391,7 +1391,7 @@ function ingestSuccess$b(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$c(config) {
+function createResourceRequest$e(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -1405,7 +1405,7 @@ function createResourceRequest$c(config) {
     };
 }
-const adapterName$c = 'createApp';
+const adapterName$e = 'createApp';
 const createApp_ConfigPropertyMetadata = [
     generateParamConfigMetadata('assetIcon', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
@@ -1418,11 +1418,11 @@ const createApp_ConfigPropertyMetadata = [
     generateParamConfigMetadata('templateValues', false, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('templateVersion', false, 2 /* Body */, 0 /* String */),
 ];
-const createApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, createApp_ConfigPropertyMetadata);
-const createResourceParams$c = /*#__PURE__*/ createResourceParams$e(createApp_ConfigPropertyMetadata);
-function typeCheckConfig$c(untrustedConfig) {
+const createApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, createApp_ConfigPropertyMetadata);
+const createResourceParams$e = /*#__PURE__*/ createResourceParams$g(createApp_ConfigPropertyMetadata);
+function typeCheckConfig$e(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, createApp_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, createApp_ConfigPropertyMetadata);
     const untrustedConfig_templateValues = untrustedConfig.templateValues;
     if (untrustedIsObject(untrustedConfig_templateValues)) {
         const untrustedConfig_templateValues_object = {};
@@ -1440,30 +1440,30 @@ function typeCheckConfig$c(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$c(untrustedConfig);
+    const config = typeCheckConfig$e(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$c(luvio, config, options) {
-    const resourceParams = createResourceParams$c(config);
-    const request = createResourceRequest$c(resourceParams);
+function buildNetworkSnapshot$e(luvio, config, options) {
+    const resourceParams = createResourceParams$e(config);
+    const request = createResourceRequest$e(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$b(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$c(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$e(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1473,33 +1473,33 @@ function buildNetworkSnapshot$c(luvio, config, options) {
 }
 const createAppAdapterFactory = (luvio) => {
     return function createApp(untrustedConfig) {
-        const config = validateAdapterConfig$c(untrustedConfig, createApp_ConfigPropertyNames);
+        const config = validateAdapterConfig$e(untrustedConfig, createApp_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createApp"');
         }
-        return buildNetworkSnapshot$c(luvio, config);
+        return buildNetworkSnapshot$e(luvio, config);
     };
 };
-function keyBuilder$p(luvio, params) {
-    return keyBuilder$t(luvio, {
+function keyBuilder$q(luvio, params) {
+    return keyBuilder$u(luvio, {
         id: params.urlParams.appIdOrApiName
     });
 }
-function getResponseCacheKeys$b(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$p(luvio, resourceParams);
+function getResponseCacheKeys$d(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$q(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
         representationName: RepresentationType$b,
         mergeable: false
     });
 }
-function evictSuccess(luvio, resourceParams) {
-    const key = keyBuilder$p(luvio, resourceParams);
+function evictSuccess$1(luvio, resourceParams) {
+    const key = keyBuilder$q(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$b(config) {
+function createResourceRequest$d(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -1513,41 +1513,41 @@ function createResourceRequest$b(config) {
     };
 }
-const adapterName$b = 'deleteApp';
+const adapterName$d = 'deleteApp';
 const deleteApp_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, deleteApp_ConfigPropertyMetadata);
-const createResourceParams$b = /*#__PURE__*/ createResourceParams$e(deleteApp_ConfigPropertyMetadata);
-function typeCheckConfig$b(untrustedConfig) {
+const deleteApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, deleteApp_ConfigPropertyMetadata);
+const createResourceParams$d = /*#__PURE__*/ createResourceParams$g(deleteApp_ConfigPropertyMetadata);
+function typeCheckConfig$d(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, deleteApp_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, deleteApp_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$b(untrustedConfig);
+    const config = typeCheckConfig$d(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$b(luvio, config, options) {
-    const resourceParams = createResourceParams$b(config);
-    const request = createResourceRequest$b(resourceParams);
+function buildNetworkSnapshot$d(luvio, config, options) {
+    const resourceParams = createResourceParams$d(config);
+    const request = createResourceRequest$d(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
-            evictSuccess(luvio, resourceParams);
+            evictSuccess$1(luvio, resourceParams);
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$b(cache, luvio, resourceParams);
+            getResponseCacheKeys$d(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -1557,33 +1557,33 @@ function buildNetworkSnapshot$b(luvio, config, options) {
 }
 const deleteAppAdapterFactory = (luvio) => {
     return function AppFrameworkdeleteApp(untrustedConfig) {
-        const config = validateAdapterConfig$b(untrustedConfig, deleteApp_ConfigPropertyNames);
+        const config = validateAdapterConfig$d(untrustedConfig, deleteApp_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$b}"`);
+            throw new Error(`Invalid config for "${adapterName$d}"`);
         }
-        return buildNetworkSnapshot$b(luvio, config);
+        return buildNetworkSnapshot$d(luvio, config);
     };
 };
-function select$p(luvio, params) {
-    return select$u();
+function select$q(luvio, params) {
+    return select$v();
 }
-function keyBuilder$o(luvio, params) {
-    return keyBuilder$t(luvio, {
+function keyBuilder$p(luvio, params) {
+    return keyBuilder$u(luvio, {
         id: params.urlParams.appIdOrApiName
     });
 }
-function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$b(storeKeyMap, luvio, response);
 }
-function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$o(luvio, resourceParams);
+    const key = keyBuilder$p(luvio, resourceParams);
     luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$p(),
+        node: select$q(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1595,7 +1595,7 @@ function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$8(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$o(luvio, params);
+    const key = keyBuilder$p(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$b,
@@ -1606,7 +1606,7 @@ function ingestError$8(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$a(config) {
+function createResourceRequest$c(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -1620,60 +1620,60 @@ function createResourceRequest$a(config) {
     };
 }
-const adapterName$a = 'getApp';
+const adapterName$c = 'getApp';
 const getApp_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getApp_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$e(getApp_ConfigPropertyMetadata);
-function keyBuilder$n(luvio, config) {
-    const resourceParams = createResourceParams$a(config);
-    return keyBuilder$o(luvio, resourceParams);
+const getApp_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, getApp_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$g(getApp_ConfigPropertyMetadata);
+function keyBuilder$o(luvio, config) {
+    const resourceParams = createResourceParams$c(config);
+    return keyBuilder$p(luvio, resourceParams);
 }
-function typeCheckConfig$a(untrustedConfig) {
+function typeCheckConfig$c(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, getApp_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getApp_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$a(untrustedConfig);
+    const config = typeCheckConfig$c(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$8(luvio, config) {
-    createResourceParams$a(config);
-    return select$p();
+    createResourceParams$c(config);
+    return select$q();
 }
 function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$8(luvio, config, resourceParams, response) {
     const snapshot = ingestError$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$a(luvio, config, options) {
-    const resourceParams = createResourceParams$a(config);
-    const request = createResourceRequest$a(resourceParams);
+function buildNetworkSnapshot$c(luvio, config, options) {
+    const resourceParams = createResourceParams$c(config);
+    const request = createResourceRequest$c(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1681,23 +1681,23 @@ function buildNetworkSnapshot$a(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$n(luvio, config),
+        recordId: keyBuilder$o(luvio, config),
         node: adapterFragment$8(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getAppAdapterFactory = (luvio) => function AppFramework__getApp(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$a(untrustedConfig, getApp_ConfigPropertyNames);
+    const config = validateAdapterConfig$c(untrustedConfig, getApp_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -1751,7 +1751,7 @@ function validate$k(obj, path = 'AppActivityItemRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$8 = 'AppActivityItemRepresentation';
-function keyBuilder$m(luvio, config) {
+function keyBuilder$n(luvio, config) {
     return keyPrefix + '::' + RepresentationType$8 + ':' + config.appId + ':' + config.id;
 }
 function keyBuilderFromType$6(luvio, object) {
@@ -1759,12 +1759,12 @@ function keyBuilderFromType$6(luvio, object) {
         appId: object.appId,
         id: object.id
     };
-    return keyBuilder$m(luvio, keyParams);
+    return keyBuilder$n(luvio, keyParams);
 }
 function normalize$8(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$o = function AppActivityItemRepresentationSelect() {
+const select$p = function AppActivityItemRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$e,
@@ -1877,14 +1877,14 @@ function validate$j(obj, path = 'AppActivityCollectionRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$7 = 'AppActivityCollectionRepresentation';
-function keyBuilder$l(luvio, config) {
+function keyBuilder$m(luvio, config) {
     return keyPrefix + '::' + RepresentationType$7 + ':' + config.appId;
 }
 function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         appId: object.appId
     };
-    return keyBuilder$l(luvio, keyParams);
+    return keyBuilder$m(luvio, keyParams);
 }
 function normalize$7(input, existing, path, luvio, store, timestamp) {
     const input_items = input.items;
@@ -1905,7 +1905,7 @@ function normalize$7(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$n = function AppActivityCollectionRepresentationSelect() {
+const select$o = function AppActivityCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$d,
@@ -1919,7 +1919,7 @@ const select$n = function AppActivityCollectionRepresentationSelect() {
                 name: 'items',
                 kind: 'Link',
                 plural: true,
-                fragment: select$o()
+                fragment: select$p()
             }
         ]
     };
@@ -1968,24 +1968,24 @@ function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$m(luvio, params) {
-    return select$n();
+function select$n(luvio, params) {
+    return select$o();
 }
-function keyBuilder$k(luvio, params) {
-    return keyBuilder$l(luvio, {
+function keyBuilder$l(luvio, params) {
+    return keyBuilder$m(luvio, {
         appId: params.urlParams.appIdOrApiName
     });
 }
-function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$7(storeKeyMap, luvio, response);
 }
-function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$k(luvio, resourceParams);
+    const key = keyBuilder$l(luvio, resourceParams);
     luvio.storeIngest(key, ingest$7, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$m(),
+        node: select$n(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1997,7 +1997,7 @@ function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$7(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$k(luvio, params);
+    const key = keyBuilder$l(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$7,
@@ -2008,7 +2008,7 @@ function ingestError$7(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$9(config) {
+function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -2022,60 +2022,60 @@ function createResourceRequest$9(config) {
     };
 }
-const adapterName$9 = 'getAppActivities';
+const adapterName$b = 'getAppActivities';
 const getAppActivities_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getAppActivities_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getAppActivities_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$e(getAppActivities_ConfigPropertyMetadata);
-function keyBuilder$j(luvio, config) {
-    const resourceParams = createResourceParams$9(config);
-    return keyBuilder$k(luvio, resourceParams);
+const getAppActivities_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, getAppActivities_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$g(getAppActivities_ConfigPropertyMetadata);
+function keyBuilder$k(luvio, config) {
+    const resourceParams = createResourceParams$b(config);
+    return keyBuilder$l(luvio, resourceParams);
 }
-function typeCheckConfig$9(untrustedConfig) {
+function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, getAppActivities_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getAppActivities_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$9(untrustedConfig);
+    const config = typeCheckConfig$b(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$7(luvio, config) {
-    createResourceParams$9(config);
-    return select$m();
+    createResourceParams$b(config);
+    return select$n();
 }
 function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$7(luvio, config, resourceParams, response) {
     const snapshot = ingestError$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$9(luvio, config, options) {
-    const resourceParams = createResourceParams$9(config);
-    const request = createResourceRequest$9(resourceParams);
+function buildNetworkSnapshot$b(luvio, config, options) {
+    const resourceParams = createResourceParams$b(config);
+    const request = createResourceRequest$b(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2083,23 +2083,23 @@ function buildNetworkSnapshot$9(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$b, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$j(luvio, config),
+        recordId: keyBuilder$k(luvio, config),
         node: adapterFragment$7(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getAppActivitiesAdapterFactory = (luvio) => function AppFramework__getAppActivities(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$9(untrustedConfig, getAppActivities_ConfigPropertyNames);
+    const config = validateAdapterConfig$b(untrustedConfig, getAppActivities_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -2108,25 +2108,25 @@ const getAppActivitiesAdapterFactory = (luvio) => function AppFramework__getAppA
     buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$7);
 };
-function select$l(luvio, params) {
-    return select$o();
+function select$m(luvio, params) {
+    return select$p();
 }
-function keyBuilder$i(luvio, params) {
-    return keyBuilder$m(luvio, {
+function keyBuilder$j(luvio, params) {
+    return keyBuilder$n(luvio, {
         appId: params.urlParams.appIdOrApiName,
         id: params.urlParams.id
     });
 }
-function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$8(storeKeyMap, luvio, response);
 }
-function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$i(luvio, resourceParams);
+    const key = keyBuilder$j(luvio, resourceParams);
     luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$l(),
+        node: select$m(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2138,7 +2138,7 @@ function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$6(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$i(luvio, params);
+    const key = keyBuilder$j(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$8,
@@ -2149,7 +2149,7 @@ function ingestError$6(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$8(config) {
+function createResourceRequest$a(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -2163,61 +2163,61 @@ function createResourceRequest$8(config) {
     };
 }
-const adapterName$8 = 'getAppActivity';
+const adapterName$a = 'getAppActivity';
 const getAppActivity_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('id', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getAppActivity_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getAppActivity_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$e(getAppActivity_ConfigPropertyMetadata);
-function keyBuilder$h(luvio, config) {
-    const resourceParams = createResourceParams$8(config);
-    return keyBuilder$i(luvio, resourceParams);
+const getAppActivity_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getAppActivity_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$g(getAppActivity_ConfigPropertyMetadata);
+function keyBuilder$i(luvio, config) {
+    const resourceParams = createResourceParams$a(config);
+    return keyBuilder$j(luvio, resourceParams);
 }
-function typeCheckConfig$8(untrustedConfig) {
+function typeCheckConfig$a(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, getAppActivity_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getAppActivity_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8(untrustedConfig);
+    const config = typeCheckConfig$a(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$6(luvio, config) {
-    createResourceParams$8(config);
-    return select$l();
+    createResourceParams$a(config);
+    return select$m();
 }
 function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$6(luvio, config, resourceParams, response) {
     const snapshot = ingestError$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$8(luvio, config, options) {
-    const resourceParams = createResourceParams$8(config);
-    const request = createResourceRequest$8(resourceParams);
+function buildNetworkSnapshot$a(luvio, config, options) {
+    const resourceParams = createResourceParams$a(config);
+    const request = createResourceRequest$a(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2225,23 +2225,23 @@ function buildNetworkSnapshot$8(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$h(luvio, config),
+        recordId: keyBuilder$i(luvio, config),
         node: adapterFragment$6(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getAppActivityAdapterFactory = (luvio) => function AppFramework__getAppActivity(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$8(untrustedConfig, getAppActivity_ConfigPropertyNames);
+    const config = validateAdapterConfig$a(untrustedConfig, getAppActivity_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -2406,19 +2406,19 @@ function validate$i(obj, path = 'AssetRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$6 = 'AssetRepresentation';
-function keyBuilder$g(luvio, config) {
+function keyBuilder$h(luvio, config) {
     return keyPrefix + '::' + RepresentationType$6 + ':' + config.id;
 }
 function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$g(luvio, keyParams);
+    return keyBuilder$h(luvio, keyParams);
 }
 function normalize$6(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$k = function AssetRepresentationSelect() {
+const select$l = function AssetRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$c,
@@ -2552,14 +2552,14 @@ function validate$h(obj, path = 'AssetCollectionRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$5 = 'AssetCollectionRepresentation';
-function keyBuilder$f(luvio, config) {
+function keyBuilder$g(luvio, config) {
     return keyPrefix + '::' + RepresentationType$5 + ':' + config.appId;
 }
 function keyBuilderFromType$3(luvio, object) {
     const keyParams = {
         appId: object.appId
     };
-    return keyBuilder$f(luvio, keyParams);
+    return keyBuilder$g(luvio, keyParams);
 }
 function normalize$5(input, existing, path, luvio, store, timestamp) {
     const input_assets = input.assets;
@@ -2580,7 +2580,7 @@ function normalize$5(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$j = function AssetCollectionRepresentationSelect() {
+const select$k = function AssetCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$b,
@@ -2594,7 +2594,7 @@ const select$j = function AssetCollectionRepresentationSelect() {
                 name: 'assets',
                 kind: 'Link',
                 plural: true,
-                fragment: select$k()
+                fragment: select$l()
             }
         ]
     };
@@ -2643,24 +2643,24 @@ function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$i(luvio, params) {
-    return select$j();
+function select$j(luvio, params) {
+    return select$k();
 }
-function keyBuilder$e(luvio, params) {
-    return keyBuilder$f(luvio, {
+function keyBuilder$f(luvio, params) {
+    return keyBuilder$g(luvio, {
         appId: params.urlParams.appIdOrApiName
     });
 }
-function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$5(storeKeyMap, luvio, response);
 }
-function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$e(luvio, resourceParams);
+    const key = keyBuilder$f(luvio, resourceParams);
     luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$i(),
+        node: select$j(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2672,7 +2672,7 @@ function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$5(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$e(luvio, params);
+    const key = keyBuilder$f(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$5,
@@ -2683,7 +2683,7 @@ function ingestError$5(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$7(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -2697,62 +2697,62 @@ function createResourceRequest$7(config) {
     };
 }
-const adapterName$7 = 'getAppAssets';
+const adapterName$9 = 'getAppAssets';
 const getAppAssets_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('assetType', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('templateAssetName', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getAppAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getAppAssets_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$e(getAppAssets_ConfigPropertyMetadata);
-function keyBuilder$d(luvio, config) {
-    const resourceParams = createResourceParams$7(config);
-    return keyBuilder$e(luvio, resourceParams);
+const getAppAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getAppAssets_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$g(getAppAssets_ConfigPropertyMetadata);
+function keyBuilder$e(luvio, config) {
+    const resourceParams = createResourceParams$9(config);
+    return keyBuilder$f(luvio, resourceParams);
 }
-function typeCheckConfig$7(untrustedConfig) {
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, getAppAssets_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getAppAssets_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$7(untrustedConfig);
+    const config = typeCheckConfig$9(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$5(luvio, config) {
-    createResourceParams$7(config);
-    return select$i();
+    createResourceParams$9(config);
+    return select$j();
 }
 function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$5(luvio, config, resourceParams, response) {
     const snapshot = ingestError$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$7(luvio, config, options) {
-    const resourceParams = createResourceParams$7(config);
-    const request = createResourceRequest$7(resourceParams);
+function buildNetworkSnapshot$9(luvio, config, options) {
+    const resourceParams = createResourceParams$9(config);
+    const request = createResourceRequest$9(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2760,23 +2760,23 @@ function buildNetworkSnapshot$7(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$d(luvio, config),
+        recordId: keyBuilder$e(luvio, config),
         node: adapterFragment$5(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getAppAssetsAdapterFactory = (luvio) => function AppFramework__getAppAssets(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$7(untrustedConfig, getAppAssets_ConfigPropertyNames);
+    const config = validateAdapterConfig$9(untrustedConfig, getAppAssets_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -2827,7 +2827,7 @@ function normalize$4(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$h = function InstalledAssetCollectionRepresentationSelect() {
+const select$i = function InstalledAssetCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$a,
@@ -2837,7 +2837,7 @@ const select$h = function InstalledAssetCollectionRepresentationSelect() {
                 name: 'assets',
                 kind: 'Link',
                 plural: true,
-                fragment: select$k()
+                fragment: select$l()
             }
         ]
     };
@@ -2881,22 +2881,22 @@ function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$g(luvio, params) {
-    return select$h();
+function select$h(luvio, params) {
+    return select$i();
 }
-function keyBuilder$c(luvio, params) {
+function keyBuilder$d(luvio, params) {
     return keyPrefix + '::InstalledAssetCollectionRepresentation:(' + 'assetIdOrName:' + params.queryParams.assetIdOrName + ',' + 'assetType:' + params.queryParams.assetType + ')';
 }
-function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$c(luvio, resourceParams));
+function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$d(luvio, resourceParams));
 }
-function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$c(luvio, resourceParams);
+    const key = keyBuilder$d(luvio, resourceParams);
     luvio.storeIngest(key, ingest$4, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$g(),
+        node: select$h(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2908,7 +2908,7 @@ function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$4(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$c(luvio, params);
+    const key = keyBuilder$d(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$4,
@@ -2919,7 +2919,7 @@ function ingestError$4(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$6(config) {
+function createResourceRequest$8(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -2933,61 +2933,61 @@ function createResourceRequest$6(config) {
     };
 }
-const adapterName$6 = 'getInstalledAssets';
+const adapterName$8 = 'getInstalledAssets';
 const getInstalledAssets_ConfigPropertyMetadata = [
     generateParamConfigMetadata('assetIdOrName', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('assetType', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getInstalledAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getInstalledAssets_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$e(getInstalledAssets_ConfigPropertyMetadata);
-function keyBuilder$b(luvio, config) {
-    const resourceParams = createResourceParams$6(config);
-    return keyBuilder$c(luvio, resourceParams);
+const getInstalledAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getInstalledAssets_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$g(getInstalledAssets_ConfigPropertyMetadata);
+function keyBuilder$c(luvio, config) {
+    const resourceParams = createResourceParams$8(config);
+    return keyBuilder$d(luvio, resourceParams);
 }
-function typeCheckConfig$6(untrustedConfig) {
+function typeCheckConfig$8(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, getInstalledAssets_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getInstalledAssets_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$6(untrustedConfig);
+    const config = typeCheckConfig$8(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$4(luvio, config) {
-    createResourceParams$6(config);
-    return select$g();
+    createResourceParams$8(config);
+    return select$h();
 }
 function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$4(luvio, config, resourceParams, response) {
     const snapshot = ingestError$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$6(luvio, config, options) {
-    const resourceParams = createResourceParams$6(config);
-    const request = createResourceRequest$6(resourceParams);
+function buildNetworkSnapshot$8(luvio, config, options) {
+    const resourceParams = createResourceParams$8(config);
+    const request = createResourceRequest$8(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2995,23 +2995,23 @@ function buildNetworkSnapshot$6(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$b(luvio, config),
+        recordId: keyBuilder$c(luvio, config),
         node: adapterFragment$4(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getInstalledAssetsAdapterFactory = (luvio) => function AppFramework__getInstalledAssets(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$6(untrustedConfig, getInstalledAssets_ConfigPropertyNames);
+    const config = validateAdapterConfig$8(untrustedConfig, getInstalledAssets_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -3153,19 +3153,19 @@ function validate$f(obj, path = 'TemplateRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$3 = 'TemplateRepresentation';
-function keyBuilder$a(luvio, config) {
+function keyBuilder$b(luvio, config) {
     return keyPrefix + '::' + RepresentationType$3 + ':' + config.id;
 }
 function keyBuilderFromType$2(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$a(luvio, keyParams);
+    return keyBuilder$b(luvio, keyParams);
 }
 function normalize$3(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$f = function TemplateRepresentationSelect() {
+const select$g = function TemplateRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$9,
@@ -3337,7 +3337,7 @@ function normalize$2(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$e = function TemplateCollectionRepresentationSelect() {
+const select$f = function TemplateCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$8,
@@ -3347,7 +3347,7 @@ const select$e = function TemplateCollectionRepresentationSelect() {
                 name: 'templates',
                 kind: 'Link',
                 plural: true,
-                fragment: select$f()
+                fragment: select$g()
             }
         ]
     };
@@ -3391,22 +3391,22 @@ function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$d(luvio, params) {
-    return select$e();
+function select$e(luvio, params) {
+    return select$f();
 }
-function keyBuilder$9(luvio, params) {
+function keyBuilder$a(luvio, params) {
     return keyPrefix + '::TemplateCollectionRepresentation:(' + ')';
 }
-function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$2(storeKeyMap, luvio, response, () => keyBuilder$9());
+function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response, () => keyBuilder$a());
 }
-function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$9();
+    const key = keyBuilder$a();
     luvio.storeIngest(key, ingest$2, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$d(),
+        node: select$e(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3418,7 +3418,7 @@ function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$3(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$9();
+    const key = keyBuilder$a();
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$2,
@@ -3429,7 +3429,7 @@ function ingestError$3(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$5(config) {
+function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -3443,57 +3443,57 @@ function createResourceRequest$5(config) {
     };
 }
-const adapterName$5 = 'getTemplates';
+const adapterName$7 = 'getTemplates';
 const getTemplates_ConfigPropertyMetadata = [];
-const getTemplates_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getTemplates_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$e(getTemplates_ConfigPropertyMetadata);
-function keyBuilder$8(luvio, config) {
-    createResourceParams$5(config);
-    return keyBuilder$9();
+const getTemplates_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, getTemplates_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$g(getTemplates_ConfigPropertyMetadata);
+function keyBuilder$9(luvio, config) {
+    createResourceParams$7(config);
+    return keyBuilder$a();
 }
-function typeCheckConfig$5(untrustedConfig) {
+function typeCheckConfig$7(untrustedConfig) {
     const config = {};
     return config;
 }
-function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$5();
+    const config = typeCheckConfig$7();
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$3(luvio, config) {
-    createResourceParams$5(config);
-    return select$d();
+    createResourceParams$7(config);
+    return select$e();
 }
 function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$3(luvio, config, resourceParams, response) {
     const snapshot = ingestError$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$5(luvio, config, options) {
-    const resourceParams = createResourceParams$5(config);
-    const request = createResourceRequest$5();
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7();
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3501,23 +3501,23 @@ function buildNetworkSnapshot$5(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$7, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$8(luvio, config),
+        recordId: keyBuilder$9(luvio, config),
         node: adapterFragment$3(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$7(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getTemplatesAdapterFactory = (luvio) => function AppFramework__getTemplates(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$5(untrustedConfig, getTemplates_ConfigPropertyNames);
+    const config = validateAdapterConfig$7(untrustedConfig, getTemplates_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -3690,19 +3690,19 @@ function validate$8(obj, path = 'RuleInfoInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-function select$c(luvio, params) {
-    return select$f();
+function select$d(luvio, params) {
+    return select$g();
 }
-function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$3(storeKeyMap, luvio, response);
 }
-function ingestSuccess$4(luvio, resourceParams, response) {
+function ingestSuccess$5(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$2(luvio, body);
     luvio.storeIngest(key, ingest$3, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$c(),
+        node: select$d(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3713,7 +3713,7 @@ function ingestSuccess$4(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$4(config) {
+function createResourceRequest$6(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -3727,7 +3727,7 @@ function createResourceRequest$4(config) {
     };
 }
-const adapterName$4 = 'createTemplate';
+const adapterName$6 = 'createTemplate';
 const createTemplate_ConfigPropertyMetadata = [
     generateParamConfigMetadata('assetVersion', false, 2 /* Body */, 2 /* Number */),
     generateParamConfigMetadata('chainDefinitions', false, 2 /* Body */, 4 /* Unsupported */, true),
@@ -3745,11 +3745,11 @@ const createTemplate_ConfigPropertyMetadata = [
     generateParamConfigMetadata('templateType', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('variableDefinition', false, 2 /* Body */, 0 /* String */),
 ];
-const createTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, createTemplate_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$e(createTemplate_ConfigPropertyMetadata);
-function typeCheckConfig$4(untrustedConfig) {
+const createTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, createTemplate_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$g(createTemplate_ConfigPropertyMetadata);
+function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, createTemplate_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, createTemplate_ConfigPropertyMetadata);
     const untrustedConfig_chainDefinitions = untrustedConfig.chainDefinitions;
     if (ArrayIsArray$1(untrustedConfig_chainDefinitions)) {
         const untrustedConfig_chainDefinitions_array = [];
@@ -3801,30 +3801,30 @@ function typeCheckConfig$4(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$4(untrustedConfig);
+    const config = typeCheckConfig$6(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$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6(config);
+    const request = createResourceRequest$6(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$4(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$5(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3834,33 +3834,33 @@ function buildNetworkSnapshot$4(luvio, config, options) {
 }
 const createTemplateAdapterFactory = (luvio) => {
     return function createTemplate(untrustedConfig) {
-        const config = validateAdapterConfig$4(untrustedConfig, createTemplate_ConfigPropertyNames);
+        const config = validateAdapterConfig$6(untrustedConfig, createTemplate_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createTemplate"');
         }
-        return buildNetworkSnapshot$4(luvio, config);
+        return buildNetworkSnapshot$6(luvio, config);
     };
 };
-function select$b(luvio, params) {
-    return select$f();
+function select$c(luvio, params) {
+    return select$g();
 }
-function keyBuilder$7(luvio, params) {
-    return keyBuilder$a(luvio, {
+function keyBuilder$8(luvio, params) {
+    return keyBuilder$b(luvio, {
         id: params.urlParams.templateIdOrApiName
     });
 }
-function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$3(storeKeyMap, luvio, response);
 }
-function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$7(luvio, resourceParams);
+    const key = keyBuilder$8(luvio, resourceParams);
     luvio.storeIngest(key, ingest$3, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$b(),
+        node: select$c(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3872,7 +3872,7 @@ function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$2(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$7(luvio, params);
+    const key = keyBuilder$8(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$3,
@@ -3883,7 +3883,7 @@ function ingestError$2(luvio, params, error, snapshotRefresh) {
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$3(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v63.0',
@@ -3897,60 +3897,60 @@ function createResourceRequest$3(config) {
     };
 }
-const adapterName$3 = 'getTemplate';
+const adapterName$5 = 'getTemplate';
 const getTemplate_ConfigPropertyMetadata = [
     generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getTemplate_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$e(getTemplate_ConfigPropertyMetadata);
-function keyBuilder$6(luvio, config) {
-    const resourceParams = createResourceParams$3(config);
-    return keyBuilder$7(luvio, resourceParams);
+const getTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getTemplate_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$g(getTemplate_ConfigPropertyMetadata);
+function keyBuilder$7(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$8(luvio, resourceParams);
 }
-function typeCheckConfig$3(untrustedConfig) {
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, getTemplate_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getTemplate_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$3(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
 function adapterFragment$2(luvio, config) {
-    createResourceParams$3(config);
-    return select$b();
+    createResourceParams$5(config);
+    return select$c();
 }
 function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
+    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(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$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(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$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$3(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3958,23 +3958,23 @@ function buildNetworkSnapshot$3(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$6(luvio, config),
+        recordId: keyBuilder$7(luvio, config),
         node: adapterFragment$2(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getTemplateAdapterFactory = (luvio) => function AppFramework__getTemplate(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$3(untrustedConfig, getTemplate_ConfigPropertyNames);
+    const config = validateAdapterConfig$5(untrustedConfig, getTemplate_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -3983,6 +3983,188 @@ const getTemplateAdapterFactory = (luvio) => function AppFramework__getTemplate(
     buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
 };
+function select$b(luvio, params) {
+    return select$g();
+}
+function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response);
+}
+function ingestSuccess$3(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$3, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$b(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$4(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v63.0',
+        basePath: '/app-framework/templates/' + config.urlParams.templateIdOrApiName + '',
+        method: 'patch',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+const adapterName$4 = 'updateTemplate';
+const updateTemplate_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('releaseInfo', false, 2 /* Body */, 4 /* Unsupported */),
+    generateParamConfigMetadata('label', false, 2 /* Body */, 0 /* String */),
+];
+const updateTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, updateTemplate_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$g(updateTemplate_ConfigPropertyMetadata);
+function typeCheckConfig$4(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$g(untrustedConfig, config, updateTemplate_ConfigPropertyMetadata);
+    const untrustedConfig_releaseInfo = untrustedConfig.releaseInfo;
+    const referenceReleaseInfoInputRepresentationValidationError = validate$9(untrustedConfig_releaseInfo);
+    if (referenceReleaseInfoInputRepresentationValidationError === null) {
+        config.releaseInfo = untrustedConfig_releaseInfo;
+    }
+    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((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$3(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const updateTemplateAdapterFactory = (luvio) => {
+    return function updateTemplate(untrustedConfig) {
+        const config = validateAdapterConfig$4(untrustedConfig, updateTemplate_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "updateTemplate"');
+        }
+        return buildNetworkSnapshot$4(luvio, config);
+    };
+};
+function keyBuilder$6(luvio, params) {
+    return keyBuilder$b(luvio, {
+        id: params.urlParams.templateIdOrApiName
+    });
+}
+function getResponseCacheKeys$3(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$6(luvio, resourceParams);
+    cacheKeyMap.set(key, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$3,
+        mergeable: false
+    });
+}
+function evictSuccess(luvio, resourceParams) {
+    const key = keyBuilder$6(luvio, resourceParams);
+    luvio.storeEvict(key);
+}
+function createResourceRequest$3(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v63.0',
+        basePath: '/app-framework/templates/' + config.urlParams.templateIdOrApiName + '',
+        method: 'delete',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+const adapterName$3 = 'deleteTemplate';
+const deleteTemplate_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
+];
+const deleteTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, deleteTemplate_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$g(deleteTemplate_ConfigPropertyMetadata);
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$g(untrustedConfig, config, deleteTemplate_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$3(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$3(cache, luvio, resourceParams);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const deleteTemplateAdapterFactory = (luvio) => {
+    return function AppFrameworkdeleteTemplate(untrustedConfig) {
+        const config = validateAdapterConfig$3(untrustedConfig, deleteTemplate_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName$3}"`);
+        }
+        return buildNetworkSnapshot$3(luvio, config);
+    };
+};
 const VERSION$7 = "c0e40695f975d64bf46ee8f48e2b5f38";
 function validate$7(obj, path = 'ImageReferenceRepresentation') {
     const v_error = (() => {
@@ -4787,14 +4969,14 @@ const getTemplateConfig_ConfigPropertyMetadata = [
     generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getTemplateConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getTemplateConfig_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$e(getTemplateConfig_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$g(getTemplateConfig_ConfigPropertyMetadata);
 function keyBuilder$3(luvio, config) {
     const resourceParams = createResourceParams$2(config);
     return keyBuilder$4(luvio, resourceParams);
 }
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, getTemplateConfig_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getTemplateConfig_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
@@ -5027,14 +5209,14 @@ const getTags_ConfigPropertyMetadata = [
     generateParamConfigMetadata('templateIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getTags_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$e(getTags_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$g(getTags_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams$1(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, getTags_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getTags_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
@@ -5151,10 +5333,10 @@ const setTags_ConfigPropertyMetadata = [
     generateParamConfigMetadata('tags', false, 2 /* Body */, 4 /* Unsupported */),
 ];
 const setTags_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, setTags_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$e(setTags_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$g(setTags_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$e(untrustedConfig, config, setTags_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, setTags_ConfigPropertyMetadata);
     const untrustedConfig_tags = untrustedConfig.tags;
     if (untrustedIsObject(untrustedConfig_tags)) {
         const untrustedConfig_tags_object = {};
@@ -5214,4 +5396,4 @@ const setTagsAdapterFactory = (luvio) => {
     };
 };
-export { createAppAdapterFactory, createTemplateAdapterFactory, deleteAppAdapterFactory, getAppActivitiesAdapterFactory, getAppActivityAdapterFactory, getAppAdapterFactory, getAppAssetsAdapterFactory, getAppsAdapterFactory, getInstalledAssetsAdapterFactory, getTagsAdapterFactory, getTemplateAdapterFactory, getTemplateConfigAdapterFactory, getTemplatesAdapterFactory, setTagsAdapterFactory };
+export { createAppAdapterFactory, createTemplateAdapterFactory, deleteAppAdapterFactory, deleteTemplateAdapterFactory, getAppActivitiesAdapterFactory, getAppActivityAdapterFactory, getAppAdapterFactory, getAppAssetsAdapterFactory, getAppsAdapterFactory, getInstalledAssetsAdapterFactory, getTagsAdapterFactory, getTemplateAdapterFactory, getTemplateConfigAdapterFactory, getTemplatesAdapterFactory, setTagsAdapterFactory, updateTemplateAdapterFactory };