npm - @salesforce/lds-adapters-analytics-unifiedanalytics - Versions diffs - 1.297.0 → 1.298.0 - Mend

@salesforce/lds-adapters-analytics-unifiedanalytics 1.297.0 → 1.298.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 (36) hide show

package/dist/es/es2018/analytics-unifiedanalytics.js CHANGED Viewed

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
-import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$f, typeCheckConfig as typeCheckConfig$f, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$6 } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$j, typeCheckConfig as typeCheckConfig$j, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$7 } from '@luvio/engine';
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -93,7 +93,7 @@ function createLink(ref) {
     };
 }
-function validate$k(obj, path = 'BaseAnalyticsRepresentation') {
+function validate$e(obj, path = 'BaseAnalyticsRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -128,8 +128,8 @@ function validate$k(obj, path = 'BaseAnalyticsRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-function validate$j(obj, path = 'AnalyticsUserRepresentation') {
-    const validateBaseAnalyticsRepresentation_validateError = validate$k(obj, path);
+function validate$d(obj, path = 'AnalyticsUserRepresentation') {
+    const validateBaseAnalyticsRepresentation_validateError = validate$e(obj, path);
     if (validateBaseAnalyticsRepresentation_validateError !== null) {
         return validateBaseAnalyticsRepresentation_validateError;
     }
@@ -169,8 +169,8 @@ function validate$j(obj, path = 'AnalyticsUserRepresentation') {
     return v_error === undefined ? null : v_error;
 }
-function validate$i(obj, path = 'AnalyticsAssetsQueryResultsWorkspaceRepresentation') {
-    const validateBaseAnalyticsRepresentation_validateError = validate$k(obj, path);
+function validate$c(obj, path = 'AnalyticsAssetsQueryResultsWorkspaceRepresentation') {
+    const validateBaseAnalyticsRepresentation_validateError = validate$e(obj, path);
     if (validateBaseAnalyticsRepresentation_validateError !== null) {
         return validateBaseAnalyticsRepresentation_validateError;
     }
@@ -182,8 +182,8 @@ function validate$i(obj, path = 'AnalyticsAssetsQueryResultsWorkspaceRepresentat
     return v_error === undefined ? null : v_error;
 }
-function validate$h(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation') {
-    const validateBaseAnalyticsRepresentation_validateError = validate$k(obj, path);
+function validate$b(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation') {
+    const validateBaseAnalyticsRepresentation_validateError = validate$e(obj, path);
     if (validateBaseAnalyticsRepresentation_validateError !== null) {
         return validateBaseAnalyticsRepresentation_validateError;
     }
@@ -198,7 +198,7 @@ function validate$h(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation')
         }
         const obj_createdBy = obj.createdBy;
         const path_createdBy = path + '.createdBy';
-        const referencepath_createdByValidationError = validate$j(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$d(obj_createdBy, path_createdBy);
         if (referencepath_createdByValidationError !== null) {
             let message = 'Object doesn\'t match AnalyticsUserRepresentation (at "' + path_createdBy + '")\n';
             message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -211,7 +211,7 @@ function validate$h(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation')
         }
         const obj_lastModifiedBy = obj.lastModifiedBy;
         const path_lastModifiedBy = path + '.lastModifiedBy';
-        const referencepath_lastModifiedByValidationError = validate$j(obj_lastModifiedBy, path_lastModifiedBy);
+        const referencepath_lastModifiedByValidationError = validate$d(obj_lastModifiedBy, path_lastModifiedBy);
         if (referencepath_lastModifiedByValidationError !== null) {
             let message = 'Object doesn\'t match AnalyticsUserRepresentation (at "' + path_lastModifiedBy + '")\n';
             message += referencepath_lastModifiedByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -224,7 +224,7 @@ function validate$h(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation')
         }
         const obj_owner = obj.owner;
         const path_owner = path + '.owner';
-        const referencepath_ownerValidationError = validate$j(obj_owner, path_owner);
+        const referencepath_ownerValidationError = validate$d(obj_owner, path_owner);
         if (referencepath_ownerValidationError !== null) {
             let message = 'Object doesn\'t match AnalyticsUserRepresentation (at "' + path_owner + '")\n';
             message += referencepath_ownerValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -232,7 +232,7 @@ function validate$h(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation')
         }
         const obj_workspace = obj.workspace;
         const path_workspace = path + '.workspace';
-        const referencepath_workspaceValidationError = validate$i(obj_workspace, path_workspace);
+        const referencepath_workspaceValidationError = validate$c(obj_workspace, path_workspace);
         if (referencepath_workspaceValidationError !== null) {
             let message = 'Object doesn\'t match AnalyticsAssetsQueryResultsWorkspaceRepresentation (at "' + path_workspace + '")\n';
             message += referencepath_workspaceValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -242,9 +242,9 @@ function validate$h(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation')
     return v_error === undefined ? null : v_error;
 }
-const TTL$3 = 500;
+const TTL$2 = 500;
 const VERSION$9 = "ed60d9cca169a3e5ed897c67d11a23db";
-function validate$g(obj, path = 'AnalyticsAssetsQueryResultsRepresentation') {
+function validate$a(obj, path = 'AnalyticsAssetsQueryResultsRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -257,7 +257,7 @@ function validate$g(obj, path = 'AnalyticsAssetsQueryResultsRepresentation') {
         for (let i = 0; i < obj_items.length; i++) {
             const obj_items_item = obj_items[i];
             const path_items_item = path_items + '[' + i + ']';
-            const referencepath_items_itemValidationError = validate$h(obj_items_item, path_items_item);
+            const referencepath_items_itemValidationError = validate$b(obj_items_item, path_items_item);
             if (referencepath_items_itemValidationError !== null) {
                 let message = 'Object doesn\'t match AnalyticsAssetsQueryResultsItemRepresentation (at "' + path_items_item + '")\n';
                 message += referencepath_items_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -283,19 +283,19 @@ function validate$g(obj, path = 'AnalyticsAssetsQueryResultsRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$9 = 'AnalyticsAssetsQueryResultsRepresentation';
-function keyBuilder$k(luvio, config) {
+function keyBuilder$o(luvio, config) {
     return keyPrefix + '::' + RepresentationType$9 + ':' + config.searchId;
 }
 function keyBuilderFromType$6(luvio, object) {
     const keyParams = {
         searchId: object.queryKey
     };
-    return keyBuilder$k(luvio, keyParams);
+    return keyBuilder$o(luvio, keyParams);
 }
 function normalize$9(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$m = function AnalyticsAssetsQueryResultsRepresentationSelect() {
+const select$o = function AnalyticsAssetsQueryResultsRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$9,
@@ -311,13 +311,13 @@ function equals$9(existing, incoming) {
 }
 const ingest$9 = function AnalyticsAssetsQueryResultsRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$g(input);
+        const validateError = validate$a(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$6(luvio, input);
-    const ttlToUse = TTL$3;
+    const ttlToUse = TTL$2;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$9, "UnifiedAnalytics", VERSION$9, RepresentationType$9, equals$9);
     return createLink(key);
 };
@@ -331,19 +331,19 @@ function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
-function select$l(luvio, params) {
-    return select$m();
+function select$n(luvio, params) {
+    return select$o();
 }
-function getResponseCacheKeys$e(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$i(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$c(luvio, resourceParams, response) {
+function ingestSuccess$e(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$6(luvio, body);
     luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$l(),
+        node: select$n(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -354,7 +354,7 @@ function ingestSuccess$c(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$e(config) {
+function createResourceRequest$i(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -368,7 +368,7 @@ function createResourceRequest$e(config) {
     };
 }
-const adapterName$e = 'queryAssets';
+const adapterName$i = 'queryAssets';
 const queryAssets_ConfigPropertyMetadata = [
     generateParamConfigMetadata('filters', true, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('limit', true, 2 /* Body */, 3 /* Integer */),
@@ -377,11 +377,11 @@ const queryAssets_ConfigPropertyMetadata = [
     generateParamConfigMetadata('searchTerm', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('sortDirection', true, 2 /* Body */, 0 /* String */),
 ];
-const queryAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, queryAssets_ConfigPropertyMetadata);
-const createResourceParams$e = /*#__PURE__*/ createResourceParams$f(queryAssets_ConfigPropertyMetadata);
-function typeCheckConfig$e(untrustedConfig) {
+const queryAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$i, queryAssets_ConfigPropertyMetadata);
+const createResourceParams$i = /*#__PURE__*/ createResourceParams$j(queryAssets_ConfigPropertyMetadata);
+function typeCheckConfig$i(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, queryAssets_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, queryAssets_ConfigPropertyMetadata);
     const untrustedConfig_filters = untrustedConfig.filters;
     if (untrustedIsObject(untrustedConfig_filters)) {
         const untrustedConfig_filters_object = {};
@@ -391,30 +391,30 @@ function typeCheckConfig$e(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$i(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$e(untrustedConfig);
+    const config = typeCheckConfig$i(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$e(luvio, config, options) {
-    const resourceParams = createResourceParams$e(config);
-    const request = createResourceRequest$e(resourceParams);
+function buildNetworkSnapshot$i(luvio, config, options) {
+    const resourceParams = createResourceParams$i(config);
+    const request = createResourceRequest$i(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$c(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$e(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$e(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$i(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -424,17 +424,17 @@ function buildNetworkSnapshot$e(luvio, config, options) {
 }
 const queryAssetsAdapterFactory = (luvio) => {
     return function queryAssets(untrustedConfig) {
-        const config = validateAdapterConfig$e(untrustedConfig, queryAssets_ConfigPropertyNames);
+        const config = validateAdapterConfig$i(untrustedConfig, queryAssets_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "queryAssets"');
         }
-        return buildNetworkSnapshot$e(luvio, config);
+        return buildNetworkSnapshot$i(luvio, config);
     };
 };
 const VERSION$8 = "d2ae5ba5bf518760e6df8195c528fdee";
-function validate$f(obj, path = 'DashboardRepresentation') {
+function validate$9(obj, path = 'DashboardRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -525,19 +525,19 @@ function validate$f(obj, path = 'DashboardRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$8 = 'DashboardRepresentation';
-function keyBuilder$j(luvio, config) {
+function keyBuilder$n(luvio, config) {
     return keyPrefix + '::' + RepresentationType$8 + ':' + config.name;
 }
 function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         name: object.cacheableKey
     };
-    return keyBuilder$j(luvio, keyParams);
+    return keyBuilder$n(luvio, keyParams);
 }
 function normalize$8(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$k = function DashboardRepresentationSelect() {
+const select$m = function DashboardRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$8,
@@ -553,7 +553,7 @@ function equals$8(existing, incoming) {
 }
 const ingest$8 = function DashboardRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$f(input);
+        const validateError = validate$9(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -574,7 +574,7 @@ function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
 }
 const VERSION$7 = "962823130e6a9315240ef0e0f0c5f757";
-function validate$e(obj, path = 'DashboardCollectionRepresentation') {
+function validate$8(obj, path = 'DashboardCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -614,7 +614,7 @@ function normalize$7(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$j = function DashboardCollectionRepresentationSelect() {
+const select$l = function DashboardCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$7,
@@ -624,7 +624,7 @@ const select$j = function DashboardCollectionRepresentationSelect() {
                 name: 'dashboards',
                 kind: 'Link',
                 plural: true,
-                fragment: select$k()
+                fragment: select$m()
             }
         ]
     };
@@ -644,7 +644,7 @@ function equals$7(existing, incoming) {
 }
 const ingest$7 = function DashboardCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$e(input);
+        const validateError = validate$8(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -668,22 +668,22 @@ function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$i(luvio, params) {
-    return select$j();
+function select$k(luvio, params) {
+    return select$l();
 }
-function keyBuilder$i(luvio, params) {
+function keyBuilder$m(luvio, params) {
     return keyPrefix + '::DashboardCollectionRepresentation:(' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ')';
 }
-function getResponseCacheKeys$d(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$7(storeKeyMap, luvio, response, () => keyBuilder$i(luvio, resourceParams));
+function getResponseCacheKeys$h(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$7(storeKeyMap, luvio, response, () => keyBuilder$m(luvio, resourceParams));
 }
-function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$d(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$i(luvio, resourceParams);
+    const key = keyBuilder$m(luvio, resourceParams);
     luvio.storeIngest(key, ingest$7, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$i(),
+        node: select$k(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -694,13 +694,13 @@ function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$5(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$i(luvio, params);
+function ingestError$6(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$m(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$d(config) {
+function createResourceRequest$h(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -714,106 +714,106 @@ function createResourceRequest$d(config) {
     };
 }
-const adapterName$d = 'getDashboards';
+const adapterName$h = 'getDashboards';
 const getDashboards_ConfigPropertyMetadata = [
     generateParamConfigMetadata('limit', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
 ];
-const getDashboards_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, getDashboards_ConfigPropertyMetadata);
-const createResourceParams$d = /*#__PURE__*/ createResourceParams$f(getDashboards_ConfigPropertyMetadata);
-function keyBuilder$h(luvio, config) {
-    const resourceParams = createResourceParams$d(config);
-    return keyBuilder$i(luvio, resourceParams);
+const getDashboards_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, getDashboards_ConfigPropertyMetadata);
+const createResourceParams$h = /*#__PURE__*/ createResourceParams$j(getDashboards_ConfigPropertyMetadata);
+function keyBuilder$l(luvio, config) {
+    const resourceParams = createResourceParams$h(config);
+    return keyBuilder$m(luvio, resourceParams);
 }
-function typeCheckConfig$d(untrustedConfig) {
+function typeCheckConfig$h(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getDashboards_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, getDashboards_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$h(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$d(untrustedConfig);
+    const config = typeCheckConfig$h(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$5(luvio, config) {
-    createResourceParams$d(config);
-    return select$i();
+function adapterFragment$6(luvio, config) {
+    createResourceParams$h(config);
+    return select$k();
 }
-function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
+function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$d(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$5(luvio, resourceParams, response, {
+function onFetchResponseError$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$h(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$h(luvio, config, options) {
+    const resourceParams = createResourceParams$h(config);
+    const request = createResourceRequest$h(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$d(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$h(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$6(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext, buildNetworkSnapshot$d, undefined, false);
+function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$h, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$h(luvio, config),
-        node: adapterFragment$5(luvio, config),
+        recordId: keyBuilder$l(luvio, config),
+        node: adapterFragment$6(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDashboardsAdapterFactory = (luvio) => function UnifiedAnalytics__getDashboards(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$d(untrustedConfig, getDashboards_ConfigPropertyNames);
+    const config = validateAdapterConfig$h(untrustedConfig, getDashboards_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
+    buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$6);
 };
-function select$h(luvio, params) {
-    return select$k();
+function select$j(luvio, params) {
+    return select$m();
 }
-function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$g(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$8(storeKeyMap, luvio, response);
 }
-function ingestSuccess$a(luvio, resourceParams, response) {
+function ingestSuccess$c(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$5(luvio, body);
     luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$h(),
+        node: select$j(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -824,7 +824,7 @@ function ingestSuccess$a(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$c(config) {
+function createResourceRequest$g(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -838,7 +838,7 @@ function createResourceRequest$c(config) {
     };
 }
-const adapterName$c = 'createDashboard';
+const adapterName$g = 'createDashboard';
 const createDashboard_ConfigPropertyMetadata = [
     generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('id', false, 2 /* Body */, 0 /* String */),
@@ -847,11 +847,11 @@ const createDashboard_ConfigPropertyMetadata = [
     generateParamConfigMetadata('layouts', true, 2 /* Body */, 4 /* Unsupported */, true),
     generateParamConfigMetadata('widgets', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, createDashboard_ConfigPropertyMetadata);
-const createResourceParams$c = /*#__PURE__*/ createResourceParams$f(createDashboard_ConfigPropertyMetadata);
-function typeCheckConfig$c(untrustedConfig) {
+const createDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, createDashboard_ConfigPropertyMetadata);
+const createResourceParams$g = /*#__PURE__*/ createResourceParams$j(createDashboard_ConfigPropertyMetadata);
+function typeCheckConfig$g(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, createDashboard_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, createDashboard_ConfigPropertyMetadata);
     const untrustedConfig_layouts = untrustedConfig.layouts;
     if (ArrayIsArray$1(untrustedConfig_layouts)) {
         const untrustedConfig_layouts_array = [];
@@ -878,30 +878,30 @@ function typeCheckConfig$c(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$c(untrustedConfig);
+    const config = typeCheckConfig$g(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$g(luvio, config, options) {
+    const resourceParams = createResourceParams$g(config);
+    const request = createResourceRequest$g(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$a(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$g(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -911,33 +911,33 @@ function buildNetworkSnapshot$c(luvio, config, options) {
 }
 const createDashboardAdapterFactory = (luvio) => {
     return function createDashboard(untrustedConfig) {
-        const config = validateAdapterConfig$c(untrustedConfig, createDashboard_ConfigPropertyNames);
+        const config = validateAdapterConfig$g(untrustedConfig, createDashboard_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createDashboard"');
         }
-        return buildNetworkSnapshot$c(luvio, config);
+        return buildNetworkSnapshot$g(luvio, config);
     };
 };
-function keyBuilder$g(luvio, params) {
-    return keyBuilder$j(luvio, {
+function keyBuilder$k(luvio, params) {
+    return keyBuilder$n(luvio, {
         name: params.urlParams.dashboardIdOrApiName
     });
 }
-function getResponseCacheKeys$b(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$g(luvio, resourceParams);
+function getResponseCacheKeys$f(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$k(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
         representationName: RepresentationType$8,
         mergeable: false
     });
 }
-function evictSuccess$1(luvio, resourceParams) {
-    const key = keyBuilder$g(luvio, resourceParams);
+function evictSuccess$3(luvio, resourceParams) {
+    const key = keyBuilder$k(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$b(config) {
+function createResourceRequest$f(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -951,41 +951,41 @@ function createResourceRequest$b(config) {
     };
 }
-const adapterName$b = 'deleteDashboard';
+const adapterName$f = 'deleteDashboard';
 const deleteDashboard_ConfigPropertyMetadata = [
     generateParamConfigMetadata('dashboardIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, deleteDashboard_ConfigPropertyMetadata);
-const createResourceParams$b = /*#__PURE__*/ createResourceParams$f(deleteDashboard_ConfigPropertyMetadata);
-function typeCheckConfig$b(untrustedConfig) {
+const deleteDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, deleteDashboard_ConfigPropertyMetadata);
+const createResourceParams$f = /*#__PURE__*/ createResourceParams$j(deleteDashboard_ConfigPropertyMetadata);
+function typeCheckConfig$f(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, deleteDashboard_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, deleteDashboard_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$b(untrustedConfig);
+    const config = typeCheckConfig$f(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$f(luvio, config, options) {
+    const resourceParams = createResourceParams$f(config);
+    const request = createResourceRequest$f(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
-            evictSuccess$1(luvio, resourceParams);
+            evictSuccess$3(luvio, resourceParams);
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$b(cache, luvio, resourceParams);
+            getResponseCacheKeys$f(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -995,33 +995,33 @@ function buildNetworkSnapshot$b(luvio, config, options) {
 }
 const deleteDashboardAdapterFactory = (luvio) => {
     return function UnifiedAnalyticsdeleteDashboard(untrustedConfig) {
-        const config = validateAdapterConfig$b(untrustedConfig, deleteDashboard_ConfigPropertyNames);
+        const config = validateAdapterConfig$f(untrustedConfig, deleteDashboard_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$b}"`);
+            throw new Error(`Invalid config for "${adapterName$f}"`);
         }
-        return buildNetworkSnapshot$b(luvio, config);
+        return buildNetworkSnapshot$f(luvio, config);
     };
 };
-function select$g(luvio, params) {
-    return select$k();
+function select$i(luvio, params) {
+    return select$m();
 }
-function keyBuilder$f(luvio, params) {
-    return keyBuilder$j(luvio, {
+function keyBuilder$j(luvio, params) {
+    return keyBuilder$n(luvio, {
         name: params.urlParams.dashboardIdOrApiName
     });
 }
-function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$e(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$8(storeKeyMap, luvio, response);
 }
-function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$f(luvio, resourceParams);
+    const key = keyBuilder$j(luvio, resourceParams);
     luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$g(),
+        node: select$i(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1032,13 +1032,13 @@ function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$4(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$f(luvio, params);
+function ingestError$5(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$j(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$a(config) {
+function createResourceRequest$e(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -1052,105 +1052,105 @@ function createResourceRequest$a(config) {
     };
 }
-const adapterName$a = 'getDashboardByName';
+const adapterName$e = 'getDashboardByName';
 const getDashboardByName_ConfigPropertyMetadata = [
     generateParamConfigMetadata('dashboardIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getDashboardByName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getDashboardByName_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$f(getDashboardByName_ConfigPropertyMetadata);
-function keyBuilder$e(luvio, config) {
-    const resourceParams = createResourceParams$a(config);
-    return keyBuilder$f(luvio, resourceParams);
+const getDashboardByName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, getDashboardByName_ConfigPropertyMetadata);
+const createResourceParams$e = /*#__PURE__*/ createResourceParams$j(getDashboardByName_ConfigPropertyMetadata);
+function keyBuilder$i(luvio, config) {
+    const resourceParams = createResourceParams$e(config);
+    return keyBuilder$j(luvio, resourceParams);
 }
-function typeCheckConfig$a(untrustedConfig) {
+function typeCheckConfig$e(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getDashboardByName_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, getDashboardByName_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$a(untrustedConfig);
+    const config = typeCheckConfig$e(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$4(luvio, config) {
-    createResourceParams$a(config);
-    return select$g();
+function adapterFragment$5(luvio, config) {
+    createResourceParams$e(config);
+    return select$i();
 }
-function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
+function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$4(luvio, resourceParams, response, {
+function onFetchResponseError$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$e(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$e(luvio, config, options) {
+    const resourceParams = createResourceParams$e(config);
+    const request = createResourceRequest$e(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$e(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
+function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$e, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$e(luvio, config),
-        node: adapterFragment$4(luvio, config),
+        recordId: keyBuilder$i(luvio, config),
+        node: adapterFragment$5(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDashboardByNameAdapterFactory = (luvio) => function UnifiedAnalytics__getDashboardByName(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$a(untrustedConfig, getDashboardByName_ConfigPropertyNames);
+    const config = validateAdapterConfig$e(untrustedConfig, getDashboardByName_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
+    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
 };
-function select$f(luvio, params) {
-    return select$k();
+function select$h(luvio, params) {
+    return select$m();
 }
-function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$d(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$8(storeKeyMap, luvio, response);
 }
-function ingestSuccess$8(luvio, resourceParams, response) {
+function ingestSuccess$a(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$5(luvio, body);
     luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$f(),
+        node: select$h(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1161,7 +1161,7 @@ function ingestSuccess$8(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$9(config) {
+function createResourceRequest$d(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -1175,7 +1175,7 @@ function createResourceRequest$9(config) {
     };
 }
-const adapterName$9 = 'updateDashboard';
+const adapterName$d = 'updateDashboard';
 const updateDashboard_ConfigPropertyMetadata = [
     generateParamConfigMetadata('dashboardIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
@@ -1185,11 +1185,11 @@ const updateDashboard_ConfigPropertyMetadata = [
     generateParamConfigMetadata('layouts', true, 2 /* Body */, 4 /* Unsupported */, true),
     generateParamConfigMetadata('widgets', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const updateDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, updateDashboard_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$f(updateDashboard_ConfigPropertyMetadata);
-function typeCheckConfig$9(untrustedConfig) {
+const updateDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, updateDashboard_ConfigPropertyMetadata);
+const createResourceParams$d = /*#__PURE__*/ createResourceParams$j(updateDashboard_ConfigPropertyMetadata);
+function typeCheckConfig$d(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, updateDashboard_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, updateDashboard_ConfigPropertyMetadata);
     const untrustedConfig_layouts = untrustedConfig.layouts;
     if (ArrayIsArray$1(untrustedConfig_layouts)) {
         const untrustedConfig_layouts_array = [];
@@ -1216,30 +1216,30 @@ function typeCheckConfig$9(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$9(untrustedConfig);
+    const config = typeCheckConfig$d(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$9(luvio, config, options) {
-    const resourceParams = createResourceParams$9(config);
-    const request = createResourceRequest$9(resourceParams);
+function buildNetworkSnapshot$d(luvio, config, options) {
+    const resourceParams = createResourceParams$d(config);
+    const request = createResourceRequest$d(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$8(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$d(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1249,24 +1249,24 @@ function buildNetworkSnapshot$9(luvio, config, options) {
 }
 const updateDashboardAdapterFactory = (luvio) => {
     return function updateDashboard(untrustedConfig) {
-        const config = validateAdapterConfig$9(untrustedConfig, updateDashboard_ConfigPropertyNames);
+        const config = validateAdapterConfig$d(untrustedConfig, updateDashboard_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateDashboard"');
         }
-        return buildNetworkSnapshot$9(luvio, config);
+        return buildNetworkSnapshot$d(luvio, config);
     };
 };
 const VERSION$6 = "13e8e39beeffee6e3f13ac9a24b8e8be";
-function validate$d(obj, path = 'AnalyticsVisualizationRepresentation') {
+function validate$7(obj, path = 'AnalyticsVisualizationRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_createdBy = obj.createdBy;
         const path_createdBy = path + '.createdBy';
-        const referencepath_createdByValidationError = validate$j(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$d(obj_createdBy, path_createdBy);
         if (referencepath_createdByValidationError !== null) {
             let message = 'Object doesn\'t match AnalyticsUserRepresentation (at "' + path_createdBy + '")\n';
             message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1302,7 +1302,7 @@ function validate$d(obj, path = 'AnalyticsVisualizationRepresentation') {
         if (obj.lastModifiedBy !== undefined) {
             const obj_lastModifiedBy = obj.lastModifiedBy;
             const path_lastModifiedBy = path + '.lastModifiedBy';
-            const referencepath_lastModifiedByValidationError = validate$j(obj_lastModifiedBy, path_lastModifiedBy);
+            const referencepath_lastModifiedByValidationError = validate$d(obj_lastModifiedBy, path_lastModifiedBy);
             if (referencepath_lastModifiedByValidationError !== null) {
                 let message = 'Object doesn\'t match AnalyticsUserRepresentation (at "' + path_lastModifiedBy + '")\n';
                 message += referencepath_lastModifiedByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1325,19 +1325,19 @@ function validate$d(obj, path = 'AnalyticsVisualizationRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$6 = 'AnalyticsVisualizationRepresentation';
-function keyBuilder$d(luvio, config) {
+function keyBuilder$h(luvio, config) {
     return keyPrefix + '::' + RepresentationType$6 + ':' + config.name;
 }
 function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         name: object.name
     };
-    return keyBuilder$d(luvio, keyParams);
+    return keyBuilder$h(luvio, keyParams);
 }
 function normalize$6(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$e = function AnalyticsVisualizationRepresentationSelect() {
+const select$g = function AnalyticsVisualizationRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$6,
@@ -1353,7 +1353,7 @@ function equals$6(existing, incoming) {
 }
 const ingest$6 = function AnalyticsVisualizationRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$d(input);
+        const validateError = validate$7(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1374,7 +1374,7 @@ function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
 }
 const VERSION$5 = "342da25bfe5e13c7f4ccbc8aa0980a4f";
-function validate$c(obj, path = 'AnalyticsVisualizationCollectionRepresentation') {
+function validate$6(obj, path = 'AnalyticsVisualizationCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1414,7 +1414,7 @@ function normalize$5(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$d = function AnalyticsVisualizationCollectionRepresentationSelect() {
+const select$f = function AnalyticsVisualizationCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$5,
@@ -1424,7 +1424,7 @@ const select$d = function AnalyticsVisualizationCollectionRepresentationSelect()
                 name: 'visualizations',
                 kind: 'Link',
                 plural: true,
-                fragment: select$e()
+                fragment: select$g()
             }
         ]
     };
@@ -1444,7 +1444,7 @@ function equals$5(existing, incoming) {
 }
 const ingest$5 = function AnalyticsVisualizationCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$c(input);
+        const validateError = validate$6(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1468,22 +1468,22 @@ function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$c(luvio, params) {
-    return select$d();
+function select$e(luvio, params) {
+    return select$f();
 }
-function keyBuilder$c(luvio, params) {
+function keyBuilder$g(luvio, params) {
     return keyPrefix + '::AnalyticsVisualizationCollectionRepresentation:(' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ')';
 }
-function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$5(storeKeyMap, luvio, response, () => keyBuilder$c(luvio, resourceParams));
+function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$5(storeKeyMap, luvio, response, () => keyBuilder$g(luvio, resourceParams));
 }
-function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$c(luvio, resourceParams);
+    const key = keyBuilder$g(luvio, resourceParams);
     luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$c(),
+        node: select$e(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1494,13 +1494,13 @@ function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$3(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$c(luvio, params);
+function ingestError$4(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$g(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$8(config) {
+function createResourceRequest$c(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -1514,111 +1514,111 @@ function createResourceRequest$8(config) {
     };
 }
-const adapterName$8 = 'getVisualizations';
+const adapterName$c = 'getVisualizations';
 const getVisualizations_ConfigPropertyMetadata = [
     generateParamConfigMetadata('limit', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
 ];
-const getVisualizations_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getVisualizations_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$f(getVisualizations_ConfigPropertyMetadata);
-function keyBuilder$b(luvio, config) {
-    const resourceParams = createResourceParams$8(config);
-    return keyBuilder$c(luvio, resourceParams);
+const getVisualizations_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, getVisualizations_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$j(getVisualizations_ConfigPropertyMetadata);
+function keyBuilder$f(luvio, config) {
+    const resourceParams = createResourceParams$c(config);
+    return keyBuilder$g(luvio, resourceParams);
 }
-function typeCheckConfig$8(untrustedConfig) {
+function typeCheckConfig$c(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getVisualizations_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, getVisualizations_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8(untrustedConfig);
+    const config = typeCheckConfig$c(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$3(luvio, config) {
-    createResourceParams$8(config);
-    return select$c();
+function adapterFragment$4(luvio, config) {
+    createResourceParams$c(config);
+    return select$e();
 }
-function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$3(luvio, resourceParams, response, {
+function onFetchResponseError$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(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$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$3(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
+function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$b(luvio, config),
-        node: adapterFragment$3(luvio, config),
+        recordId: keyBuilder$f(luvio, config),
+        node: adapterFragment$4(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getVisualizationsAdapterFactory = (luvio) => function UnifiedAnalytics__getVisualizations(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$8(untrustedConfig, getVisualizations_ConfigPropertyNames);
+    const config = validateAdapterConfig$c(untrustedConfig, getVisualizations_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
 };
-function keyBuilder$a(luvio, params) {
-    return keyBuilder$d(luvio, {
+function keyBuilder$e(luvio, params) {
+    return keyBuilder$h(luvio, {
         name: params.urlParams.visualizationIdOrApiName
     });
 }
-function getResponseCacheKeys$7(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$a(luvio, resourceParams);
+function getResponseCacheKeys$b(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$e(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
         representationName: RepresentationType$6,
         mergeable: false
     });
 }
-function evictSuccess(luvio, resourceParams) {
-    const key = keyBuilder$a(luvio, resourceParams);
+function evictSuccess$2(luvio, resourceParams) {
+    const key = keyBuilder$e(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$7(config) {
+function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -1632,41 +1632,41 @@ function createResourceRequest$7(config) {
     };
 }
-const adapterName$7 = 'deleteVisualization';
+const adapterName$b = 'deleteVisualization';
 const deleteVisualization_ConfigPropertyMetadata = [
     generateParamConfigMetadata('visualizationIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteVisualization_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, deleteVisualization_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$f(deleteVisualization_ConfigPropertyMetadata);
-function typeCheckConfig$7(untrustedConfig) {
+const deleteVisualization_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, deleteVisualization_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$j(deleteVisualization_ConfigPropertyMetadata);
+function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, deleteVisualization_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, deleteVisualization_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$7(untrustedConfig);
+    const config = typeCheckConfig$b(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$7(luvio, config, options) {
-    const resourceParams = createResourceParams$7(config);
-    const request = createResourceRequest$7(resourceParams);
+function buildNetworkSnapshot$b(luvio, config, options) {
+    const resourceParams = createResourceParams$b(config);
+    const request = createResourceRequest$b(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
-            evictSuccess(luvio, resourceParams);
+            evictSuccess$2(luvio, resourceParams);
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$7(cache, luvio, resourceParams);
+            getResponseCacheKeys$b(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -1676,33 +1676,33 @@ function buildNetworkSnapshot$7(luvio, config, options) {
 }
 const deleteVisualizationAdapterFactory = (luvio) => {
     return function UnifiedAnalyticsdeleteVisualization(untrustedConfig) {
-        const config = validateAdapterConfig$7(untrustedConfig, deleteVisualization_ConfigPropertyNames);
+        const config = validateAdapterConfig$b(untrustedConfig, deleteVisualization_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$7}"`);
+            throw new Error(`Invalid config for "${adapterName$b}"`);
         }
-        return buildNetworkSnapshot$7(luvio, config);
+        return buildNetworkSnapshot$b(luvio, config);
     };
 };
-function select$b(luvio, params) {
-    return select$e();
+function select$d(luvio, params) {
+    return select$g();
 }
-function keyBuilder$9(luvio, params) {
-    return keyBuilder$d(luvio, {
+function keyBuilder$d(luvio, params) {
+    return keyBuilder$h(luvio, {
         name: params.urlParams.visualizationIdOrApiName
     });
 }
-function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$6(storeKeyMap, luvio, response);
 }
-function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$9(luvio, resourceParams);
+    const key = keyBuilder$d(luvio, resourceParams);
     luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$b(),
+        node: select$d(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1713,13 +1713,13 @@ function ingestSuccess$6(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$2(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$9(luvio, params);
+function ingestError$3(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$d(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$6(config) {
+function createResourceRequest$a(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -1733,101 +1733,106 @@ function createResourceRequest$6(config) {
     };
 }
-const adapterName$6 = 'getVisualization';
+const adapterName$a = 'getVisualization';
 const getVisualization_ConfigPropertyMetadata = [
     generateParamConfigMetadata('visualizationIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getVisualization_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getVisualization_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$f(getVisualization_ConfigPropertyMetadata);
-function keyBuilder$8(luvio, config) {
-    const resourceParams = createResourceParams$6(config);
-    return keyBuilder$9(luvio, resourceParams);
+const getVisualization_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, getVisualization_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$j(getVisualization_ConfigPropertyMetadata);
+function keyBuilder$c(luvio, config) {
+    const resourceParams = createResourceParams$a(config);
+    return keyBuilder$d(luvio, resourceParams);
 }
-function typeCheckConfig$6(untrustedConfig) {
+function typeCheckConfig$a(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getVisualization_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, getVisualization_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$6(untrustedConfig);
+    const config = typeCheckConfig$a(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$2(luvio, config) {
-    createResourceParams$6(config);
-    return select$b();
+function adapterFragment$3(luvio, config) {
+    createResourceParams$a(config);
+    return select$d();
 }
-function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$6(luvio, resourceParams, response, {
+function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$2(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$2(luvio, resourceParams, response, {
+function onFetchResponseError$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(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$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$2(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
+function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$a, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$8(luvio, config),
-        node: adapterFragment$2(luvio, config),
+        recordId: keyBuilder$c(luvio, config),
+        node: adapterFragment$3(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$a(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getVisualizationAdapterFactory = (luvio) => function UnifiedAnalytics__getVisualization(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$6(untrustedConfig, getVisualization_ConfigPropertyNames);
+    const config = validateAdapterConfig$a(untrustedConfig, getVisualization_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
 };
-const VERSION$4 = "bb71c0bf5563bfa6de1fe757209f3722";
-function validate$b(obj, path = 'WorkspaceRepresentation') {
+const VERSION$4 = "cd4ffaf2332ab8ec006033f2e4339ad7";
+function validate$5(obj, path = 'WorkspaceRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
+        const obj_cacheableKey = obj.cacheableKey;
+        const path_cacheableKey = path + '.cacheableKey';
+        if (typeof obj_cacheableKey !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_cacheableKey + '" (at "' + path_cacheableKey + '")');
+        }
         const obj_createdBy = obj.createdBy;
         const path_createdBy = path + '.createdBy';
-        const referencepath_createdByValidationError = validate$j(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$d(obj_createdBy, path_createdBy);
         if (referencepath_createdByValidationError !== null) {
             let message = 'Object doesn\'t match AnalyticsUserRepresentation (at "' + path_createdBy + '")\n';
             message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1853,6 +1858,20 @@ function validate$b(obj, path = 'WorkspaceRepresentation') {
         if (typeof obj_label !== 'string') {
             return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
         }
+        if (obj.lastModifiedBy !== undefined) {
+            const obj_lastModifiedBy = obj.lastModifiedBy;
+            const path_lastModifiedBy = path + '.lastModifiedBy';
+            if (obj_lastModifiedBy === undefined) {
+                return new TypeError('Expected "defined" but received "' + typeof obj_lastModifiedBy + '" (at "' + path_lastModifiedBy + '")');
+            }
+        }
+        if (obj.lastModifiedDate !== undefined) {
+            const obj_lastModifiedDate = obj.lastModifiedDate;
+            const path_lastModifiedDate = path + '.lastModifiedDate';
+            if (typeof obj_lastModifiedDate !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_lastModifiedDate + '" (at "' + path_lastModifiedDate + '")');
+            }
+        }
         const obj_name = obj.name;
         const path_name = path + '.name';
         if (typeof obj_name !== 'string') {
@@ -1867,19 +1886,19 @@ function validate$b(obj, path = 'WorkspaceRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$4 = 'WorkspaceRepresentation';
-function keyBuilder$7(luvio, config) {
+function keyBuilder$b(luvio, config) {
     return keyPrefix + '::' + RepresentationType$4 + ':' + config.name;
 }
 function keyBuilderFromType$3(luvio, object) {
     const keyParams = {
-        name: object.name
+        name: object.cacheableKey
     };
-    return keyBuilder$7(luvio, keyParams);
+    return keyBuilder$b(luvio, keyParams);
 }
 function normalize$4(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$a = function WorkspaceRepresentationSelect() {
+const select$c = function WorkspaceRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$4,
@@ -1895,7 +1914,7 @@ function equals$4(existing, incoming) {
 }
 const ingest$4 = function WorkspaceRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$b(input);
+        const validateError = validate$5(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -1916,7 +1935,7 @@ function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
 }
 const VERSION$3 = "25327d65bf7ad14ee671ec5a1642b193";
-function validate$a(obj, path = 'WorkspaceCollectionRepresentation') {
+function validate$4(obj, path = 'WorkspaceCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1956,7 +1975,7 @@ function normalize$3(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$9 = function WorkspaceCollectionRepresentationSelect() {
+const select$b = function WorkspaceCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$3,
@@ -1966,7 +1985,7 @@ const select$9 = function WorkspaceCollectionRepresentationSelect() {
                 name: 'workspaces',
                 kind: 'Link',
                 plural: true,
-                fragment: select$a()
+                fragment: select$c()
             }
         ]
     };
@@ -1986,7 +2005,7 @@ function equals$3(existing, incoming) {
 }
 const ingest$3 = function WorkspaceCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$a(input);
+        const validateError = validate$4(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -2010,22 +2029,22 @@ function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
     }
 }
-function select$8(luvio, params) {
-    return select$9();
+function select$a(luvio, params) {
+    return select$b();
 }
-function keyBuilder$6(luvio, params) {
+function keyBuilder$a(luvio, params) {
     return keyPrefix + '::WorkspaceCollectionRepresentation:(' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ')';
 }
-function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$3(storeKeyMap, luvio, response, () => keyBuilder$6(luvio, resourceParams));
+function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response, () => keyBuilder$a(luvio, resourceParams));
 }
-function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$6(luvio, resourceParams);
+    const key = keyBuilder$a(luvio, resourceParams);
     luvio.storeIngest(key, ingest$3, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$8(),
+        node: select$a(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2036,13 +2055,13 @@ function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$1(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$6(luvio, params);
+function ingestError$2(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$a(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$5(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -2056,106 +2075,106 @@ function createResourceRequest$5(config) {
     };
 }
-const adapterName$5 = 'getWorkspaces';
+const adapterName$9 = 'getWorkspaces';
 const getWorkspaces_ConfigPropertyMetadata = [
     generateParamConfigMetadata('limit', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
 ];
-const getWorkspaces_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getWorkspaces_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$f(getWorkspaces_ConfigPropertyMetadata);
-function keyBuilder$5(luvio, config) {
-    const resourceParams = createResourceParams$5(config);
-    return keyBuilder$6(luvio, resourceParams);
+const getWorkspaces_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getWorkspaces_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$j(getWorkspaces_ConfigPropertyMetadata);
+function keyBuilder$9(luvio, config) {
+    const resourceParams = createResourceParams$9(config);
+    return keyBuilder$a(luvio, resourceParams);
 }
-function typeCheckConfig$5(untrustedConfig) {
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getWorkspaces_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, getWorkspaces_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$5(untrustedConfig);
+    const config = typeCheckConfig$9(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$1(luvio, config) {
-    createResourceParams$5(config);
-    return select$8();
+function adapterFragment$2(luvio, config) {
+    createResourceParams$9(config);
+    return select$a();
 }
-function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$1(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$1(luvio, resourceParams, response, {
+function onFetchResponseError$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$2(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$5(luvio, config, options) {
-    const resourceParams = createResourceParams$5(config);
-    const request = createResourceRequest$5(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$1(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$5(luvio, config),
-        node: adapterFragment$1(luvio, config),
+        recordId: keyBuilder$9(luvio, config),
+        node: adapterFragment$2(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getWorkspacesAdapterFactory = (luvio) => function UnifiedAnalytics__getWorkspaces(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$5(untrustedConfig, getWorkspaces_ConfigPropertyNames);
+    const config = validateAdapterConfig$9(untrustedConfig, getWorkspaces_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
 };
-function select$7(luvio, params) {
-    return select$a();
+function select$9(luvio, params) {
+    return select$c();
 }
-function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$4(storeKeyMap, luvio, response);
 }
-function ingestSuccess$4(luvio, resourceParams, response) {
+function ingestSuccess$6(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$3(luvio, body);
     luvio.storeIngest(key, ingest$4, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$7(),
+        node: select$9(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -2166,7 +2185,7 @@ function ingestSuccess$4(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$4(config) {
+function createResourceRequest$8(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
@@ -2180,44 +2199,44 @@ function createResourceRequest$4(config) {
     };
 }
-const adapterName$4 = 'createWorkspace';
+const adapterName$8 = 'createWorkspace';
 const createWorkspace_ConfigPropertyMetadata = [
     generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('id', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('label', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('name', false, 2 /* Body */, 0 /* String */),
 ];
-const createWorkspace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, createWorkspace_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$f(createWorkspace_ConfigPropertyMetadata);
-function typeCheckConfig$4(untrustedConfig) {
+const createWorkspace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, createWorkspace_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$j(createWorkspace_ConfigPropertyMetadata);
+function typeCheckConfig$8(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, createWorkspace_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, createWorkspace_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$4(untrustedConfig);
+    const config = typeCheckConfig$8(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$8(luvio, config, options) {
+    const resourceParams = createResourceParams$8(config);
+    const request = createResourceRequest$8(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$4(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$6(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2227,135 +2246,38 @@ function buildNetworkSnapshot$4(luvio, config, options) {
 }
 const createWorkspaceAdapterFactory = (luvio) => {
     return function createWorkspace(untrustedConfig) {
-        const config = validateAdapterConfig$4(untrustedConfig, createWorkspace_ConfigPropertyNames);
+        const config = validateAdapterConfig$8(untrustedConfig, createWorkspace_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createWorkspace"');
         }
-        return buildNetworkSnapshot$4(luvio, config);
+        return buildNetworkSnapshot$8(luvio, config);
     };
 };
-const TTL$2 = 500;
-const VERSION$2 = "9cc9d397fbf7728f812bb0c66c128f4b";
-function validate$9(obj, path = 'SubscriptionDigestConfigOutputRepresentation') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        const obj_isEnabled = obj.isEnabled;
-        const path_isEnabled = path + '.isEnabled';
-        if (typeof obj_isEnabled !== 'boolean') {
-            return new TypeError('Expected "boolean" but received "' + typeof obj_isEnabled + '" (at "' + path_isEnabled + '")');
-        }
-        const obj_scheduleType = obj.scheduleType;
-        const path_scheduleType = path + '.scheduleType';
-        if (typeof obj_scheduleType !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_scheduleType + '" (at "' + path_scheduleType + '")');
-        }
-        const obj_userId = obj.userId;
-        const path_userId = path + '.userId';
-        if (typeof obj_userId !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_userId + '" (at "' + path_userId + '")');
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-const RepresentationType$2 = 'SubscriptionDigestConfigOutputRepresentation';
-function keyBuilder$4(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$2 + ':' + config.userId;
-}
-function keyBuilderFromType$2(luvio, object) {
-    const keyParams = {
-        userId: object.userId
-    };
-    return keyBuilder$4(luvio, keyParams);
-}
-function normalize$2(input, existing, path, luvio, store, timestamp) {
-    return input;
-}
-const select$6 = function SubscriptionDigestConfigOutputRepresentationSelect() {
-    return {
-        kind: 'Fragment',
-        version: VERSION$2,
-        private: [],
-        opaque: true
-    };
-};
-function equals$2(existing, incoming) {
-    if (JSONStringify(incoming) !== JSONStringify(existing)) {
-        return false;
-    }
-    return true;
+function keyBuilder$8(luvio, params) {
+    return keyBuilder$b(luvio, {
+        name: params.urlParams.workspaceIdOrApiName
+    });
 }
-const ingest$2 = function SubscriptionDigestConfigOutputRepresentationIngest(input, path, luvio, store, timestamp) {
-    if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$9(input);
-        if (validateError !== null) {
-            throw validateError;
-        }
-    }
-    const key = keyBuilderFromType$2(luvio, input);
-    const ttlToUse = TTL$2;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "UnifiedAnalytics", VERSION$2, RepresentationType$2, equals$2);
-    return createLink(key);
-};
-function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
-    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$2(luvio, input);
-    rootKeySet.set(rootKey, {
+function getResponseCacheKeys$7(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$8(luvio, resourceParams);
+    cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$2,
+        representationName: RepresentationType$4,
         mergeable: false
     });
 }
-function select$5(luvio, params) {
-    return select$6();
-}
-function keyBuilder$3(luvio, params) {
-    return keyBuilder$4(luvio, {
-        userId: params.urlParams.digestConfigOwner
-    });
-}
-function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$2(storeKeyMap, luvio, response);
-}
-function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
-    const { body } = response;
-    const key = keyBuilder$3(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$2, body);
-    const snapshot = luvio.storeLookup({
-        recordId: key,
-        node: select$5(),
-        variables: {},
-    }, snapshotRefresh);
-    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 ingestError(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$3(luvio, params);
-    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
-    const storeMetadataParams = {
-        ttl: TTL$2,
-        namespace: keyPrefix,
-        version: VERSION$2,
-        representationName: RepresentationType$2
-    };
-    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
-    return errorSnapshot;
+function evictSuccess$1(luvio, resourceParams) {
+    const key = keyBuilder$8(luvio, resourceParams);
+    luvio.storeEvict(key);
 }
-function createResourceRequest$3(config) {
+function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/subscriptions/digest/' + config.urlParams.digestConfigOwner + '',
-        method: 'get',
+        basePath: '/unified-analytics/workspaces/' + config.urlParams.workspaceIdOrApiName + '',
+        method: 'delete',
         body: null,
         urlParams: config.urlParams,
         queryParams: {},
@@ -2364,105 +2286,206 @@ function createResourceRequest$3(config) {
     };
 }
-const adapterName$3 = 'getSubscriptionDigestConfig';
-const getSubscriptionDigestConfig_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('digestConfigOwner', true, 0 /* UrlParameter */, 0 /* String */),
+const adapterName$7 = 'deleteWorkspace';
+const deleteWorkspace_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('workspaceIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getSubscriptionDigestConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getSubscriptionDigestConfig_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$f(getSubscriptionDigestConfig_ConfigPropertyMetadata);
-function keyBuilder$2(luvio, config) {
-    const resourceParams = createResourceParams$3(config);
-    return keyBuilder$3(luvio, resourceParams);
-}
-function typeCheckConfig$3(untrustedConfig) {
+const deleteWorkspace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, deleteWorkspace_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$j(deleteWorkspace_ConfigPropertyMetadata);
+function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getSubscriptionDigestConfig_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, deleteWorkspace_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$3(untrustedConfig);
+    const config = typeCheckConfig$7(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment(luvio, config) {
-    createResourceParams$3(config);
-    return select$5();
-}
-function onFetchResponseSuccess(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then(() => {
+        return luvio.handleSuccessResponse(() => {
+            evictSuccess$1(luvio, resourceParams);
+            return luvio.storeBroadcast();
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$7(cache, luvio, resourceParams);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
 }
-function onFetchResponseError(luvio, config, resourceParams, response) {
-    const snapshot = ingestError(luvio, resourceParams, response, {
+const deleteWorkspaceAdapterFactory = (luvio) => {
+    return function UnifiedAnalyticsdeleteWorkspace(untrustedConfig) {
+        const config = validateAdapterConfig$7(untrustedConfig, deleteWorkspace_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName$7}"`);
+        }
+        return buildNetworkSnapshot$7(luvio, config);
+    };
+};
+function select$8(luvio, params) {
+    return select$c();
+}
+function keyBuilder$7(luvio, params) {
+    return keyBuilder$b(luvio, {
+        name: params.urlParams.workspaceIdOrApiName
+    });
+}
+function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$4(storeKeyMap, luvio, response);
+}
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$7(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$8(),
+        variables: {},
+    }, snapshotRefresh);
+    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 ingestError$1(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$7(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$6(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v62.0',
+        basePath: '/unified-analytics/workspaces/' + config.urlParams.workspaceIdOrApiName + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+const adapterName$6 = 'getWorkspaceByIdOrName';
+const getWorkspaceByIdOrName_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('workspaceIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
+];
+const getWorkspaceByIdOrName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, getWorkspaceByIdOrName_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$j(getWorkspaceByIdOrName_ConfigPropertyMetadata);
+function keyBuilder$6(luvio, config) {
+    const resourceParams = createResourceParams$6(config);
+    return keyBuilder$7(luvio, resourceParams);
+}
+function typeCheckConfig$6(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$j(untrustedConfig, config, getWorkspaceByIdOrName_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$6(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$1(luvio, config) {
+    createResourceParams$6(config);
+    return select$8();
+}
+function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(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 onFetchResponseError$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$1(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+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(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
+function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$6, undefined, false);
 }
-function buildCachedSnapshotCachePolicy(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$2(luvio, config),
-        node: adapterFragment(luvio, config),
+        recordId: keyBuilder$6(luvio, config),
+        node: adapterFragment$1(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$6(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
-const getSubscriptionDigestConfigAdapterFactory = (luvio) => function UnifiedAnalytics__getSubscriptionDigestConfig(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$3(untrustedConfig, getSubscriptionDigestConfig_ConfigPropertyNames);
+const getWorkspaceByIdOrNameAdapterFactory = (luvio) => function UnifiedAnalytics__getWorkspaceByIdOrName(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$6(untrustedConfig, getWorkspaceByIdOrName_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
 };
-function select$4(luvio, params) {
-    return select$6();
+function select$7(luvio, params) {
+    return select$c();
 }
-function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$4(storeKeyMap, luvio, response);
 }
-function ingestSuccess$2(luvio, resourceParams, response) {
+function ingestSuccess$4(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$2(luvio, body);
-    luvio.storeIngest(key, ingest$2, body);
+    const key = keyBuilderFromType$3(luvio, body);
+    luvio.storeIngest(key, ingest$4, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$4(),
+        node: select$7(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -2473,11 +2496,11 @@ function ingestSuccess$2(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$2(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/subscriptions/digest/' + config.urlParams.digestConfigOwner + '',
+        basePath: '/unified-analytics/workspaces/' + config.urlParams.workspaceIdOrApiName + '',
         method: 'patch',
         body: config.body,
         urlParams: config.urlParams,
@@ -2487,43 +2510,45 @@ function createResourceRequest$2(config) {
     };
 }
-const adapterName$2 = 'updateSubscriptionDigestConfig';
-const updateSubscriptionDigestConfig_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('digestConfigOwner', true, 0 /* UrlParameter */, 0 /* String */),
-    generateParamConfigMetadata('isEnabled', true, 2 /* Body */, 1 /* Boolean */),
-    generateParamConfigMetadata('scheduleType', true, 2 /* Body */, 0 /* String */),
+const adapterName$5 = 'updateWorkspace';
+const updateWorkspace_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('workspaceIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('id', false, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('label', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('name', false, 2 /* Body */, 0 /* String */),
 ];
-const updateSubscriptionDigestConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, updateSubscriptionDigestConfig_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$f(updateSubscriptionDigestConfig_ConfigPropertyMetadata);
-function typeCheckConfig$2(untrustedConfig) {
+const updateWorkspace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, updateWorkspace_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$j(updateWorkspace_ConfigPropertyMetadata);
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, updateSubscriptionDigestConfig_ConfigPropertyMetadata);
+    typeCheckConfig$j(untrustedConfig, config, updateWorkspace_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$2(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$2(luvio, config, options) {
-    const resourceParams = createResourceParams$2(config);
-    const request = createResourceRequest$2(resourceParams);
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$2(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$4(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2531,604 +2556,325 @@ function buildNetworkSnapshot$2(luvio, config, options) {
         throw response;
     });
 }
-const updateSubscriptionDigestConfigAdapterFactory = (luvio) => {
-    return function updateSubscriptionDigestConfig(untrustedConfig) {
-        const config = validateAdapterConfig$2(untrustedConfig, updateSubscriptionDigestConfig_ConfigPropertyNames);
+const updateWorkspaceAdapterFactory = (luvio) => {
+    return function updateWorkspace(untrustedConfig) {
+        const config = validateAdapterConfig$5(untrustedConfig, updateWorkspace_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error('Invalid config for "updateSubscriptionDigestConfig"');
+            throw new Error('Invalid config for "updateWorkspace"');
         }
-        return buildNetworkSnapshot$2(luvio, config);
+        return buildNetworkSnapshot$5(luvio, config);
     };
 };
-function validate$8(obj, path = 'LibraryAssetsPreviewInputRepresentation') {
+const VERSION$2 = "4abc4f793ed7181313c3ae7365a6fb8b";
+function validate$3(obj, path = 'WorkspaceAssetRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        const obj_keys = ObjectKeys(obj);
-        for (let i = 0; i < obj_keys.length; i++) {
-            const key = obj_keys[i];
-            const obj_prop = obj[key];
-            const path_prop = path + '["' + key + '"]';
-            if (obj_prop === undefined) {
-                return new TypeError('Expected "defined" but received "' + typeof obj_prop + '" (at "' + path_prop + '")');
-            }
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-function validate$7(obj, path = 'TuaUserRepresentation') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        const obj_keys = ObjectKeys(obj);
-        for (let i = 0; i < obj_keys.length; i++) {
-            const key = obj_keys[i];
-            const obj_prop = obj[key];
-            const path_prop = path + '["' + key + '"]';
-            if (obj_prop === undefined) {
-                return new TypeError('Expected "defined" but received "' + typeof obj_prop + '" (at "' + path_prop + '")');
-            }
-        }
-    })();
-    return v_error === undefined ? null : v_error;
-}
-function validate$6(obj, path = 'TuaAssetTemplateCustomAttributesRepresentation') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        const obj_assetId = obj.assetId;
+        const path_assetId = path + '.assetId';
+        if (typeof obj_assetId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_assetId + '" (at "' + path_assetId + '")');
         }
-        const obj_label = obj.label;
-        const path_label = path + '.label';
-        let obj_label_union0 = null;
-        const obj_label_union0_error = (() => {
-            if (typeof obj_label !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
-            }
-        })();
-        if (obj_label_union0_error != null) {
-            obj_label_union0 = obj_label_union0_error.message;
+        const obj_assetType = obj.assetType;
+        const path_assetType = path + '.assetType';
+        if (typeof obj_assetType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_assetType + '" (at "' + path_assetType + '")');
         }
-        let obj_label_union1 = null;
-        const obj_label_union1_error = (() => {
-            if (obj_label !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_label + '" (at "' + path_label + '")');
-            }
-        })();
-        if (obj_label_union1_error != null) {
-            obj_label_union1 = obj_label_union1_error.message;
+        const obj_assetUsageType = obj.assetUsageType;
+        const path_assetUsageType = path + '.assetUsageType';
+        if (typeof obj_assetUsageType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_assetUsageType + '" (at "' + path_assetUsageType + '")');
         }
-        if (obj_label_union0 && obj_label_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_label + '")';
-            message += '\n' + obj_label_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_label_union1.split('\n').map((line) => '\t' + line).join('\n');
+        const obj_createdBy = obj.createdBy;
+        const path_createdBy = path + '.createdBy';
+        const referencepath_createdByValidationError = validate$d(obj_createdBy, path_createdBy);
+        if (referencepath_createdByValidationError !== null) {
+            let message = 'Object doesn\'t match AnalyticsUserRepresentation (at "' + path_createdBy + '")\n';
+            message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
             return new TypeError(message);
         }
-        const obj_values = obj.values;
-        const path_values = path + '.values';
-        if (!ArrayIsArray(obj_values)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_values + '" (at "' + path_values + '")');
-        }
-        for (let i = 0; i < obj_values.length; i++) {
-            const obj_values_item = obj_values[i];
-            const path_values_item = path_values + '[' + i + ']';
-            let obj_values_item_union0 = null;
-            const obj_values_item_union0_error = (() => {
-                if (typeof obj_values_item !== 'string') {
-                    return new TypeError('Expected "string" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
-                }
-            })();
-            if (obj_values_item_union0_error != null) {
-                obj_values_item_union0 = obj_values_item_union0_error.message;
-            }
-            let obj_values_item_union1 = null;
-            const obj_values_item_union1_error = (() => {
-                if (obj_values_item !== null) {
-                    return new TypeError('Expected "null" but received "' + typeof obj_values_item + '" (at "' + path_values_item + '")');
-                }
-            })();
-            if (obj_values_item_union1_error != null) {
-                obj_values_item_union1 = obj_values_item_union1_error.message;
-            }
-            if (obj_values_item_union0 && obj_values_item_union1) {
-                let message = 'Object doesn\'t match union (at "' + path_values_item + '")';
-                message += '\n' + obj_values_item_union0.split('\n').map((line) => '\t' + line).join('\n');
-                message += '\n' + obj_values_item_union1.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
+        const obj_createdDate = obj.createdDate;
+        const path_createdDate = path + '.createdDate';
+        if (typeof obj_createdDate !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
+        }
+        const obj_url = obj.url;
+        const path_url = path + '.url';
+        if (typeof obj_url !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_url + '" (at "' + path_url + '")');
         }
     })();
     return v_error === undefined ? null : v_error;
 }
-function validate$5(obj, path = 'TuaAssetTemplateIconsRepresentation') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        const obj_keys = ObjectKeys(obj);
-        for (let i = 0; i < obj_keys.length; i++) {
-            const key = obj_keys[i];
-            const obj_prop = obj[key];
-            const path_prop = path + '["' + key + '"]';
-            if (obj_prop === undefined) {
-                return new TypeError('Expected "defined" but received "' + typeof obj_prop + '" (at "' + path_prop + '")');
-            }
+const RepresentationType$2 = 'WorkspaceAssetRepresentation';
+function keyBuilder$5(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.assetId;
+}
+function keyBuilderFromType$2(luvio, object) {
+    const keyParams = {
+        assetId: object.assetId
+    };
+    return keyBuilder$5(luvio, keyParams);
+}
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$6 = function WorkspaceAssetRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$2,
+        private: [],
+        opaque: true
+    };
+};
+function equals$2(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$2 = function WorkspaceAssetRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$3(input);
+        if (validateError !== null) {
+            throw validateError;
         }
-    })();
-    return v_error === undefined ? null : v_error;
+    }
+    const key = keyBuilderFromType$2(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 60000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "UnifiedAnalytics", VERSION$2, RepresentationType$2, equals$2);
+    return createLink(key);
+};
+function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$2(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
 }
-function validate$4(obj, path = 'TuaAssetTemplateReleaseRepresentation') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        const obj_notesUrl = obj.notesUrl;
-        const path_notesUrl = path + '.notesUrl';
-        let obj_notesUrl_union0 = null;
-        const obj_notesUrl_union0_error = (() => {
-            if (typeof obj_notesUrl !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_notesUrl + '" (at "' + path_notesUrl + '")');
-            }
-        })();
-        if (obj_notesUrl_union0_error != null) {
-            obj_notesUrl_union0 = obj_notesUrl_union0_error.message;
-        }
-        let obj_notesUrl_union1 = null;
-        const obj_notesUrl_union1_error = (() => {
-            if (obj_notesUrl !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_notesUrl + '" (at "' + path_notesUrl + '")');
-            }
-        })();
-        if (obj_notesUrl_union1_error != null) {
-            obj_notesUrl_union1 = obj_notesUrl_union1_error.message;
-        }
-        if (obj_notesUrl_union0 && obj_notesUrl_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_notesUrl + '")';
-            message += '\n' + obj_notesUrl_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_notesUrl_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_templateVersion = obj.templateVersion;
-        const path_templateVersion = path + '.templateVersion';
-        let obj_templateVersion_union0 = null;
-        const obj_templateVersion_union0_error = (() => {
-            if (typeof obj_templateVersion !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_templateVersion + '" (at "' + path_templateVersion + '")');
-            }
-        })();
-        if (obj_templateVersion_union0_error != null) {
-            obj_templateVersion_union0 = obj_templateVersion_union0_error.message;
-        }
-        let obj_templateVersion_union1 = null;
-        const obj_templateVersion_union1_error = (() => {
-            if (obj_templateVersion !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_templateVersion + '" (at "' + path_templateVersion + '")');
-            }
-        })();
-        if (obj_templateVersion_union1_error != null) {
-            obj_templateVersion_union1 = obj_templateVersion_union1_error.message;
-        }
-        if (obj_templateVersion_union0 && obj_templateVersion_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_templateVersion + '")';
-            message += '\n' + obj_templateVersion_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_templateVersion_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
+function select$5(luvio, params) {
+    return select$6();
+}
+function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+}
+function ingestSuccess$3(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$5(),
+        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');
         }
-    })();
-    return v_error === undefined ? null : v_error;
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$4(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v62.0',
+        basePath: '/unified-analytics/workspaces/' + config.urlParams.workspaceIdOrApiName + '/assets',
+        method: 'post',
+        body: config.body,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
 }
-function validate$3(obj, path = 'LibraryAssetsPreviewOutputRepresentation') {
-    const v_error = (() => {
-        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
-            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
-        }
-        const obj_assetIcon = obj.assetIcon;
-        const path_assetIcon = path + '.assetIcon';
-        if (typeof obj_assetIcon !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_assetIcon + '" (at "' + path_assetIcon + '")');
-        }
-        obj.assetVersion;
-        const obj_configurationUrl = obj.configurationUrl;
-        const path_configurationUrl = path + '.configurationUrl';
-        if (typeof obj_configurationUrl !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_configurationUrl + '" (at "' + path_configurationUrl + '")');
-        }
-        const obj_createdBy = obj.createdBy;
-        const path_createdBy = path + '.createdBy';
-        let obj_createdBy_union0 = null;
-        const obj_createdBy_union0_error = (() => {
-            const referencepath_createdByValidationError = validate$7(obj_createdBy, path_createdBy);
-            if (referencepath_createdByValidationError !== null) {
-                let message = 'Object doesn\'t match TuaUserRepresentation (at "' + path_createdBy + '")\n';
-                message += referencepath_createdByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
-        })();
-        if (obj_createdBy_union0_error != null) {
-            obj_createdBy_union0 = obj_createdBy_union0_error.message;
-        }
-        let obj_createdBy_union1 = null;
-        const obj_createdBy_union1_error = (() => {
-            if (obj_createdBy !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_createdBy + '" (at "' + path_createdBy + '")');
-            }
-        })();
-        if (obj_createdBy_union1_error != null) {
-            obj_createdBy_union1 = obj_createdBy_union1_error.message;
-        }
-        if (obj_createdBy_union0 && obj_createdBy_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_createdBy + '")';
-            message += '\n' + obj_createdBy_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_createdBy_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_createdDate = obj.createdDate;
-        const path_createdDate = path + '.createdDate';
-        let obj_createdDate_union0 = null;
-        const obj_createdDate_union0_error = (() => {
-            if (typeof obj_createdDate !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
-            }
-        })();
-        if (obj_createdDate_union0_error != null) {
-            obj_createdDate_union0 = obj_createdDate_union0_error.message;
-        }
-        let obj_createdDate_union1 = null;
-        const obj_createdDate_union1_error = (() => {
-            if (obj_createdDate !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_createdDate + '" (at "' + path_createdDate + '")');
-            }
-        })();
-        if (obj_createdDate_union1_error != null) {
-            obj_createdDate_union1 = obj_createdDate_union1_error.message;
-        }
-        if (obj_createdDate_union0 && obj_createdDate_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_createdDate + '")';
-            message += '\n' + obj_createdDate_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_createdDate_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_customAttributes = obj.customAttributes;
-        const path_customAttributes = path + '.customAttributes';
-        if (!ArrayIsArray(obj_customAttributes)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_customAttributes + '" (at "' + path_customAttributes + '")');
-        }
-        for (let i = 0; i < obj_customAttributes.length; i++) {
-            const obj_customAttributes_item = obj_customAttributes[i];
-            const path_customAttributes_item = path_customAttributes + '[' + i + ']';
-            const referencepath_customAttributes_itemValidationError = validate$6(obj_customAttributes_item, path_customAttributes_item);
-            if (referencepath_customAttributes_itemValidationError !== null) {
-                let message = 'Object doesn\'t match TuaAssetTemplateCustomAttributesRepresentation (at "' + path_customAttributes_item + '")\n';
-                message += referencepath_customAttributes_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
-        }
-        const obj_description = obj.description;
-        const path_description = path + '.description';
-        let obj_description_union0 = null;
-        const obj_description_union0_error = (() => {
-            if (typeof obj_description !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
-            }
-        })();
-        if (obj_description_union0_error != null) {
-            obj_description_union0 = obj_description_union0_error.message;
-        }
-        let obj_description_union1 = null;
-        const obj_description_union1_error = (() => {
-            if (obj_description !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_description + '" (at "' + path_description + '")');
-            }
-        })();
-        if (obj_description_union1_error != null) {
-            obj_description_union1 = obj_description_union1_error.message;
-        }
-        if (obj_description_union0 && obj_description_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_description + '")';
-            message += '\n' + obj_description_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_description_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_icons = obj.icons;
-        const path_icons = path + '.icons';
-        const referencepath_iconsValidationError = validate$5(obj_icons, path_icons);
-        if (referencepath_iconsValidationError !== null) {
-            let message = 'Object doesn\'t match TuaAssetTemplateIconsRepresentation (at "' + path_icons + '")\n';
-            message += referencepath_iconsValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_id = obj.id;
-        const path_id = path + '.id';
-        if (typeof obj_id !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
-        }
-        const obj_label = obj.label;
-        const path_label = path + '.label';
-        if (typeof obj_label !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_label + '" (at "' + path_label + '")');
-        }
-        const obj_lastModifiedBy = obj.lastModifiedBy;
-        const path_lastModifiedBy = path + '.lastModifiedBy';
-        let obj_lastModifiedBy_union0 = null;
-        const obj_lastModifiedBy_union0_error = (() => {
-            const referencepath_lastModifiedByValidationError = validate$7(obj_lastModifiedBy, path_lastModifiedBy);
-            if (referencepath_lastModifiedByValidationError !== null) {
-                let message = 'Object doesn\'t match TuaUserRepresentation (at "' + path_lastModifiedBy + '")\n';
-                message += referencepath_lastModifiedByValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
-        })();
-        if (obj_lastModifiedBy_union0_error != null) {
-            obj_lastModifiedBy_union0 = obj_lastModifiedBy_union0_error.message;
-        }
-        let obj_lastModifiedBy_union1 = null;
-        const obj_lastModifiedBy_union1_error = (() => {
-            if (obj_lastModifiedBy !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_lastModifiedBy + '" (at "' + path_lastModifiedBy + '")');
-            }
-        })();
-        if (obj_lastModifiedBy_union1_error != null) {
-            obj_lastModifiedBy_union1 = obj_lastModifiedBy_union1_error.message;
-        }
-        if (obj_lastModifiedBy_union0 && obj_lastModifiedBy_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_lastModifiedBy + '")';
-            message += '\n' + obj_lastModifiedBy_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_lastModifiedBy_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_lastModifiedDate = obj.lastModifiedDate;
-        const path_lastModifiedDate = path + '.lastModifiedDate';
-        let obj_lastModifiedDate_union0 = null;
-        const obj_lastModifiedDate_union0_error = (() => {
-            if (typeof obj_lastModifiedDate !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_lastModifiedDate + '" (at "' + path_lastModifiedDate + '")');
-            }
-        })();
-        if (obj_lastModifiedDate_union0_error != null) {
-            obj_lastModifiedDate_union0 = obj_lastModifiedDate_union0_error.message;
-        }
-        let obj_lastModifiedDate_union1 = null;
-        const obj_lastModifiedDate_union1_error = (() => {
-            if (obj_lastModifiedDate !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_lastModifiedDate + '" (at "' + path_lastModifiedDate + '")');
-            }
-        })();
-        if (obj_lastModifiedDate_union1_error != null) {
-            obj_lastModifiedDate_union1 = obj_lastModifiedDate_union1_error.message;
-        }
-        if (obj_lastModifiedDate_union0 && obj_lastModifiedDate_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_lastModifiedDate + '")';
-            message += '\n' + obj_lastModifiedDate_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_lastModifiedDate_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_name = obj.name;
-        const path_name = path + '.name';
-        let obj_name_union0 = null;
-        const obj_name_union0_error = (() => {
-            if (typeof obj_name !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
-            }
-        })();
-        if (obj_name_union0_error != null) {
-            obj_name_union0 = obj_name_union0_error.message;
-        }
-        let obj_name_union1 = null;
-        const obj_name_union1_error = (() => {
-            if (obj_name !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_name + '" (at "' + path_name + '")');
-            }
-        })();
-        if (obj_name_union1_error != null) {
-            obj_name_union1 = obj_name_union1_error.message;
-        }
-        if (obj_name_union0 && obj_name_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_name + '")';
-            message += '\n' + obj_name_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_name_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_namespace = obj.namespace;
-        const path_namespace = path + '.namespace';
-        let obj_namespace_union0 = null;
-        const obj_namespace_union0_error = (() => {
-            if (typeof obj_namespace !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_namespace + '" (at "' + path_namespace + '")');
-            }
-        })();
-        if (obj_namespace_union0_error != null) {
-            obj_namespace_union0 = obj_namespace_union0_error.message;
-        }
-        let obj_namespace_union1 = null;
-        const obj_namespace_union1_error = (() => {
-            if (obj_namespace !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_namespace + '" (at "' + path_namespace + '")');
-            }
-        })();
-        if (obj_namespace_union1_error != null) {
-            obj_namespace_union1 = obj_namespace_union1_error.message;
-        }
-        if (obj_namespace_union0 && obj_namespace_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_namespace + '")';
-            message += '\n' + obj_namespace_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_namespace_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_releaseInfo = obj.releaseInfo;
-        const path_releaseInfo = path + '.releaseInfo';
-        const referencepath_releaseInfoValidationError = validate$4(obj_releaseInfo, path_releaseInfo);
-        if (referencepath_releaseInfoValidationError !== null) {
-            let message = 'Object doesn\'t match TuaAssetTemplateReleaseRepresentation (at "' + path_releaseInfo + '")\n';
-            message += referencepath_releaseInfoValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_tags = obj.tags;
-        const path_tags = path + '.tags';
-        if (!ArrayIsArray(obj_tags)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_tags + '" (at "' + path_tags + '")');
-        }
-        for (let i = 0; i < obj_tags.length; i++) {
-            const obj_tags_item = obj_tags[i];
-            const path_tags_item = path_tags + '[' + i + ']';
-            let obj_tags_item_union0 = null;
-            const obj_tags_item_union0_error = (() => {
-                if (typeof obj_tags_item !== 'string') {
-                    return new TypeError('Expected "string" but received "' + typeof obj_tags_item + '" (at "' + path_tags_item + '")');
-                }
-            })();
-            if (obj_tags_item_union0_error != null) {
-                obj_tags_item_union0 = obj_tags_item_union0_error.message;
-            }
-            let obj_tags_item_union1 = null;
-            const obj_tags_item_union1_error = (() => {
-                if (obj_tags_item !== null) {
-                    return new TypeError('Expected "null" but received "' + typeof obj_tags_item + '" (at "' + path_tags_item + '")');
-                }
-            })();
-            if (obj_tags_item_union1_error != null) {
-                obj_tags_item_union1 = obj_tags_item_union1_error.message;
-            }
-            if (obj_tags_item_union0 && obj_tags_item_union1) {
-                let message = 'Object doesn\'t match union (at "' + path_tags_item + '")';
-                message += '\n' + obj_tags_item_union0.split('\n').map((line) => '\t' + line).join('\n');
-                message += '\n' + obj_tags_item_union1.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
-        }
-        const obj_templateIcon = obj.templateIcon;
-        const path_templateIcon = path + '.templateIcon';
-        let obj_templateIcon_union0 = null;
-        const obj_templateIcon_union0_error = (() => {
-            if (typeof obj_templateIcon !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_templateIcon + '" (at "' + path_templateIcon + '")');
-            }
-        })();
-        if (obj_templateIcon_union0_error != null) {
-            obj_templateIcon_union0 = obj_templateIcon_union0_error.message;
-        }
-        let obj_templateIcon_union1 = null;
-        const obj_templateIcon_union1_error = (() => {
-            if (obj_templateIcon !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_templateIcon + '" (at "' + path_templateIcon + '")');
-            }
-        })();
-        if (obj_templateIcon_union1_error != null) {
-            obj_templateIcon_union1 = obj_templateIcon_union1_error.message;
-        }
-        if (obj_templateIcon_union0 && obj_templateIcon_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_templateIcon + '")';
-            message += '\n' + obj_templateIcon_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_templateIcon_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_templateType = obj.templateType;
-        const path_templateType = path + '.templateType';
-        let obj_templateType_union0 = null;
-        const obj_templateType_union0_error = (() => {
-            if (typeof obj_templateType !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_templateType + '" (at "' + path_templateType + '")');
-            }
-        })();
-        if (obj_templateType_union0_error != null) {
-            obj_templateType_union0 = obj_templateType_union0_error.message;
-        }
-        let obj_templateType_union1 = null;
-        const obj_templateType_union1_error = (() => {
-            if (obj_templateType !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_templateType + '" (at "' + path_templateType + '")');
-            }
-        })();
-        if (obj_templateType_union1_error != null) {
-            obj_templateType_union1 = obj_templateType_union1_error.message;
-        }
-        if (obj_templateType_union0 && obj_templateType_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_templateType + '")';
-            message += '\n' + obj_templateType_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_templateType_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
-        }
-        const obj_url = obj.url;
-        const path_url = path + '.url';
-        let obj_url_union0 = null;
-        const obj_url_union0_error = (() => {
-            if (typeof obj_url !== 'string') {
-                return new TypeError('Expected "string" but received "' + typeof obj_url + '" (at "' + path_url + '")');
-            }
-        })();
-        if (obj_url_union0_error != null) {
-            obj_url_union0 = obj_url_union0_error.message;
-        }
-        let obj_url_union1 = null;
-        const obj_url_union1_error = (() => {
-            if (obj_url !== null) {
-                return new TypeError('Expected "null" but received "' + typeof obj_url + '" (at "' + path_url + '")');
-            }
-        })();
-        if (obj_url_union1_error != null) {
-            obj_url_union1 = obj_url_union1_error.message;
-        }
-        if (obj_url_union0 && obj_url_union1) {
-            let message = 'Object doesn\'t match union (at "' + path_url + '")';
-            message += '\n' + obj_url_union0.split('\n').map((line) => '\t' + line).join('\n');
-            message += '\n' + obj_url_union1.split('\n').map((line) => '\t' + line).join('\n');
-            return new TypeError(message);
+const adapterName$4 = 'createWorkspaceAsset';
+const createWorkspaceAsset_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('workspaceIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('assetId', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('assetType', true, 2 /* Body */, 0 /* String */),
+    generateParamConfigMetadata('assetUsageType', true, 2 /* Body */, 0 /* String */),
+];
+const createWorkspaceAsset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, createWorkspaceAsset_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$j(createWorkspaceAsset_ConfigPropertyMetadata);
+function typeCheckConfig$4(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$j(untrustedConfig, config, createWorkspaceAsset_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$4(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((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 createWorkspaceAssetAdapterFactory = (luvio) => {
+    return function createWorkspaceAsset(untrustedConfig) {
+        const config = validateAdapterConfig$4(untrustedConfig, createWorkspaceAsset_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createWorkspaceAsset"');
         }
-    })();
-    return v_error === undefined ? null : v_error;
+        return buildNetworkSnapshot$4(luvio, config);
+    };
+};
+function keyBuilder$4(luvio, params) {
+    return keyBuilder$5(luvio, {
+        assetId: params.urlParams.assetId
+    });
+}
+function getResponseCacheKeys$3(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$4(luvio, resourceParams);
+    cacheKeyMap.set(key, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+}
+function evictSuccess(luvio, resourceParams) {
+    const key = keyBuilder$4(luvio, resourceParams);
+    luvio.storeEvict(key);
+}
+function createResourceRequest$3(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v62.0',
+        basePath: '/unified-analytics/workspaces/' + config.urlParams.workspaceIdOrApiName + '/assets/' + config.urlParams.assetId + '',
+        method: 'delete',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+const adapterName$3 = 'deleteWorkspaceAsset';
+const deleteWorkspaceAsset_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('assetId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('workspaceIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
+];
+const deleteWorkspaceAsset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, deleteWorkspaceAsset_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$j(deleteWorkspaceAsset_ConfigPropertyMetadata);
+function typeCheckConfig$3(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$j(untrustedConfig, config, deleteWorkspaceAsset_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 deleteWorkspaceAssetAdapterFactory = (luvio) => {
+    return function UnifiedAnalyticsdeleteWorkspaceAsset(untrustedConfig) {
+        const config = validateAdapterConfig$3(untrustedConfig, deleteWorkspaceAsset_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error(`Invalid config for "${adapterName$3}"`);
+        }
+        return buildNetworkSnapshot$3(luvio, config);
+    };
+};
 const TTL$1 = 500;
-const VERSION$1 = "72309d9f2b288fd243257c47590de9c1";
-function validate$2(obj, path = 'LibraryAssetsPreviewOutputCollectionRepresentation') {
+const VERSION$1 = "9cc9d397fbf7728f812bb0c66c128f4b";
+function validate$2(obj, path = 'SubscriptionDigestConfigOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        const obj_analyticsLibraryAssetPreviewRepresentationList = obj.analyticsLibraryAssetPreviewRepresentationList;
-        const path_analyticsLibraryAssetPreviewRepresentationList = path + '.analyticsLibraryAssetPreviewRepresentationList';
-        if (!ArrayIsArray(obj_analyticsLibraryAssetPreviewRepresentationList)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_analyticsLibraryAssetPreviewRepresentationList + '" (at "' + path_analyticsLibraryAssetPreviewRepresentationList + '")');
+        const obj_isEnabled = obj.isEnabled;
+        const path_isEnabled = path + '.isEnabled';
+        if (typeof obj_isEnabled !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_isEnabled + '" (at "' + path_isEnabled + '")');
         }
-        for (let i = 0; i < obj_analyticsLibraryAssetPreviewRepresentationList.length; i++) {
-            const obj_analyticsLibraryAssetPreviewRepresentationList_item = obj_analyticsLibraryAssetPreviewRepresentationList[i];
-            const path_analyticsLibraryAssetPreviewRepresentationList_item = path_analyticsLibraryAssetPreviewRepresentationList + '[' + i + ']';
-            const referencepath_analyticsLibraryAssetPreviewRepresentationList_itemValidationError = validate$3(obj_analyticsLibraryAssetPreviewRepresentationList_item, path_analyticsLibraryAssetPreviewRepresentationList_item);
-            if (referencepath_analyticsLibraryAssetPreviewRepresentationList_itemValidationError !== null) {
-                let message = 'Object doesn\'t match LibraryAssetsPreviewOutputRepresentation (at "' + path_analyticsLibraryAssetPreviewRepresentationList_item + '")\n';
-                message += referencepath_analyticsLibraryAssetPreviewRepresentationList_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
-                return new TypeError(message);
-            }
+        const obj_scheduleType = obj.scheduleType;
+        const path_scheduleType = path + '.scheduleType';
+        if (typeof obj_scheduleType !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_scheduleType + '" (at "' + path_scheduleType + '")');
         }
-        const obj_id = obj.id;
-        const path_id = path + '.id';
-        if (typeof obj_id !== 'string') {
-            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        const obj_userId = obj.userId;
+        const path_userId = path + '.userId';
+        if (typeof obj_userId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_userId + '" (at "' + path_userId + '")');
         }
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$1 = 'LibraryAssetsPreviewOutputCollectionRepresentation';
-function keyBuilder$1(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$1 + ':' + config.id;
+const RepresentationType$1 = 'SubscriptionDigestConfigOutputRepresentation';
+function keyBuilder$3(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + config.userId;
 }
 function keyBuilderFromType$1(luvio, object) {
     const keyParams = {
-        id: object.id
+        userId: object.userId
     };
-    return keyBuilder$1(luvio, keyParams);
+    return keyBuilder$3(luvio, keyParams);
 }
 function normalize$1(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$3 = function LibraryAssetsPreviewOutputCollectionRepresentationSelect() {
+const select$4 = function SubscriptionDigestConfigOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$1,
@@ -3142,7 +2888,7 @@ function equals$1(existing, incoming) {
     }
     return true;
 }
-const ingest$1 = function LibraryAssetsPreviewOutputCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$1 = function SubscriptionDigestConfigOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$2(input);
         if (validateError !== null) {
@@ -3164,9 +2910,149 @@ function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
     });
 }
-function select$2(luvio, params) {
+function select$3(luvio, params) {
+    return select$4();
+}
+function keyBuilder$2(luvio, params) {
+    return keyBuilder$3(luvio, {
+        userId: params.urlParams.digestConfigOwner
+    });
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$1(storeKeyMap, luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$2(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$1, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$3(),
+        variables: {},
+    }, snapshotRefresh);
+    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 ingestError(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$2(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$1,
+        namespace: keyPrefix,
+        version: VERSION$1,
+        representationName: RepresentationType$1
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v62.0',
+        basePath: '/unified-analytics/subscriptions/digest/' + config.urlParams.digestConfigOwner + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+const adapterName$2 = 'getSubscriptionDigestConfig';
+const getSubscriptionDigestConfig_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('digestConfigOwner', true, 0 /* UrlParameter */, 0 /* String */),
+];
+const getSubscriptionDigestConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getSubscriptionDigestConfig_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$j(getSubscriptionDigestConfig_ConfigPropertyMetadata);
+function keyBuilder$1(luvio, config) {
+    const resourceParams = createResourceParams$2(config);
+    return keyBuilder$2(luvio, resourceParams);
+}
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$j(untrustedConfig, config, getSubscriptionDigestConfig_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment(luvio, config) {
+    createResourceParams$2(config);
     return select$3();
 }
+function onFetchResponseSuccess(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError(luvio, config, resourceParams, response) {
+    const snapshot = ingestError(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
+}
+function buildCachedSnapshotCachePolicy(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$1(luvio, config),
+        node: adapterFragment(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getSubscriptionDigestConfigAdapterFactory = (luvio) => function UnifiedAnalytics__getSubscriptionDigestConfig(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$2(untrustedConfig, getSubscriptionDigestConfig_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+};
+function select$2(luvio, params) {
+    return select$4();
+}
 function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$1(storeKeyMap, luvio, response);
 }
@@ -3191,29 +3077,27 @@ function createResourceRequest$1(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/tua-analytics/assets/query',
-        method: 'post',
+        basePath: '/unified-analytics/subscriptions/digest/' + config.urlParams.digestConfigOwner + '',
+        method: 'patch',
         body: config.body,
-        urlParams: {},
+        urlParams: config.urlParams,
         queryParams: {},
         headers,
         priority: 'normal',
     };
 }
-const adapterName$1 = 'getListViewAnalyticsLibrary';
-const getListViewAnalyticsLibrary_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('input_collection', true, 2 /* Body */, 4 /* Unsupported */),
+const adapterName$1 = 'updateSubscriptionDigestConfig';
+const updateSubscriptionDigestConfig_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('digestConfigOwner', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('isEnabled', true, 2 /* Body */, 1 /* Boolean */),
+    generateParamConfigMetadata('scheduleType', true, 2 /* Body */, 0 /* String */),
 ];
-const getListViewAnalyticsLibrary_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getListViewAnalyticsLibrary_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$f(getListViewAnalyticsLibrary_ConfigPropertyMetadata);
+const updateSubscriptionDigestConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, updateSubscriptionDigestConfig_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$j(updateSubscriptionDigestConfig_ConfigPropertyMetadata);
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    const untrustedConfig_input_collection = untrustedConfig.input_collection;
-    const referenceLibraryAssetsPreviewInputRepresentationValidationError = validate$8(untrustedConfig_input_collection);
-    if (referenceLibraryAssetsPreviewInputRepresentationValidationError === null) {
-        config.input_collection = untrustedConfig_input_collection;
-    }
+    typeCheckConfig$j(untrustedConfig, config, updateSubscriptionDigestConfig_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
@@ -3247,12 +3131,12 @@ function buildNetworkSnapshot$1(luvio, config, options) {
         throw response;
     });
 }
-const getListViewAnalyticsLibraryAdapterFactory = (luvio) => {
-    return function getListViewAnalyticsLibrary(untrustedConfig) {
-        const config = validateAdapterConfig$1(untrustedConfig, getListViewAnalyticsLibrary_ConfigPropertyNames);
+const updateSubscriptionDigestConfigAdapterFactory = (luvio) => {
+    return function updateSubscriptionDigestConfig(untrustedConfig) {
+        const config = validateAdapterConfig$1(untrustedConfig, updateSubscriptionDigestConfig_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error('Invalid config for "getListViewAnalyticsLibrary"');
+            throw new Error('Invalid config for "updateSubscriptionDigestConfig"');
         }
         return buildNetworkSnapshot$1(luvio, config);
     };
@@ -3443,7 +3327,7 @@ const getUnifiedAnalyticsLibraryAssets_ConfigPropertyMetadata = [
     generateParamConfigMetadata('searchToken', false, 2 /* Body */, 4 /* Unsupported */),
 ];
 const getUnifiedAnalyticsLibraryAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getUnifiedAnalyticsLibraryAssets_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$f(getUnifiedAnalyticsLibraryAssets_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$j(getUnifiedAnalyticsLibraryAssets_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
     const untrustedConfig_assetTypes = untrustedConfig.assetTypes;
@@ -3552,4 +3436,4 @@ const getUnifiedAnalyticsLibraryAssetsAdapterFactory = (luvio) => {
     };
 };
-export { createDashboardAdapterFactory, createWorkspaceAdapterFactory, deleteDashboardAdapterFactory, deleteVisualizationAdapterFactory, getDashboardByNameAdapterFactory, getDashboardsAdapterFactory, getListViewAnalyticsLibraryAdapterFactory, getSubscriptionDigestConfigAdapterFactory, getUnifiedAnalyticsLibraryAssetsAdapterFactory, getVisualizationAdapterFactory, getVisualizationsAdapterFactory, getWorkspacesAdapterFactory, queryAssetsAdapterFactory, updateDashboardAdapterFactory, updateSubscriptionDigestConfigAdapterFactory };
+export { createDashboardAdapterFactory, createWorkspaceAdapterFactory, createWorkspaceAssetAdapterFactory, deleteDashboardAdapterFactory, deleteVisualizationAdapterFactory, deleteWorkspaceAdapterFactory, deleteWorkspaceAssetAdapterFactory, getDashboardByNameAdapterFactory, getDashboardsAdapterFactory, getSubscriptionDigestConfigAdapterFactory, getUnifiedAnalyticsLibraryAssetsAdapterFactory, getVisualizationAdapterFactory, getVisualizationsAdapterFactory, getWorkspaceByIdOrNameAdapterFactory, getWorkspacesAdapterFactory, queryAssetsAdapterFactory, updateDashboardAdapterFactory, updateSubscriptionDigestConfigAdapterFactory, updateWorkspaceAdapterFactory };