@salesforce/lds-adapters-analytics-unifiedanalytics 1.308.0-dev4 → 1.308.0-dev6

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

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$B, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$f, typeCheckConfig as typeCheckConfig$B } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$D, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$h, typeCheckConfig as typeCheckConfig$D } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -93,9 +93,9 @@ function createLink(ref) {
     };
 }
 
-const TTL$e = 1000;
-const VERSION$o = "c1d57e95aac548d53c761d2e1deeb661";
-function validate$H(obj, path = 'UnifiedAnalyticsMonitoringEventItemRepresentation') {
+const TTL$g = 1000;
+const VERSION$q = "c1d57e95aac548d53c761d2e1deeb661";
+function validate$K(obj, path = 'UnifiedAnalyticsMonitoringEventItemRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -118,68 +118,68 @@ function validate$H(obj, path = 'UnifiedAnalyticsMonitoringEventItemRepresentati
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$p = 'UnifiedAnalyticsMonitoringEventItemRepresentation';
-function keyBuilder$O(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$p + ':' + config.id;
+const RepresentationType$r = 'UnifiedAnalyticsMonitoringEventItemRepresentation';
+function keyBuilder$S(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$r + ':' + config.id;
 }
 function keyBuilderFromType$e(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$O(luvio, keyParams);
+    return keyBuilder$S(luvio, keyParams);
 }
-function normalize$o(input, existing, path, luvio, store, timestamp) {
+function normalize$q(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$U = function UnifiedAnalyticsMonitoringEventItemRepresentationSelect() {
+const select$Y = function UnifiedAnalyticsMonitoringEventItemRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$o,
+        version: VERSION$q,
         private: [],
         opaque: true
     };
 };
-function equals$o(existing, incoming) {
+function equals$q(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$o = function UnifiedAnalyticsMonitoringEventItemRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$q = function UnifiedAnalyticsMonitoringEventItemRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$H(input);
+        const validateError = validate$K(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$e(luvio, input);
-    const ttlToUse = TTL$e;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$o, "UnifiedAnalytics", VERSION$o, RepresentationType$p, equals$o);
+    const ttlToUse = TTL$g;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$q, "UnifiedAnalytics", VERSION$q, RepresentationType$r, equals$q);
     return createLink(key);
 };
-function getTypeCacheKeys$o(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$q(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = keyBuilderFromType$e(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$p,
+        representationName: RepresentationType$r,
         mergeable: false
     });
 }
 
-function select$T(luvio, params) {
-    return select$U();
+function select$X(luvio, params) {
+    return select$Y();
 }
-function getResponseCacheKeys$A(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$o(storeKeyMap, luvio, response);
+function getResponseCacheKeys$C(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$q(storeKeyMap, luvio, response);
 }
-function ingestSuccess$v(luvio, resourceParams, response) {
+function ingestSuccess$x(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$e(luvio, body);
-    luvio.storeIngest(key, ingest$o, body);
+    luvio.storeIngest(key, ingest$q, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$T(),
+        node: select$X(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -190,11 +190,11 @@ function ingestSuccess$v(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$A(config) {
+function createResourceRequest$C(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/admin/monitoring/events',
+        basePath: '/tableau/admin/monitoring/events',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -204,13 +204,13 @@ function createResourceRequest$A(config) {
     };
 }
 
-const adapterName$A = 'publish';
+const adapterName$C = 'publish';
 const publish_ConfigPropertyMetadata = [
     generateParamConfigMetadata('events', true, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const publish_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$A, publish_ConfigPropertyMetadata);
-const createResourceParams$A = /*#__PURE__*/ createResourceParams$B(publish_ConfigPropertyMetadata);
-function typeCheckConfig$A(untrustedConfig) {
+const publish_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$C, publish_ConfigPropertyMetadata);
+const createResourceParams$C = /*#__PURE__*/ createResourceParams$D(publish_ConfigPropertyMetadata);
+function typeCheckConfig$C(untrustedConfig) {
     const config = {};
     const untrustedConfig_events = untrustedConfig.events;
     if (ArrayIsArray$1(untrustedConfig_events)) {
@@ -223,30 +223,30 @@ function typeCheckConfig$A(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$A(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$C(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$A(untrustedConfig);
+    const config = typeCheckConfig$C(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$A(luvio, config, options) {
-    const resourceParams = createResourceParams$A(config);
-    const request = createResourceRequest$A(resourceParams);
+function buildNetworkSnapshot$C(luvio, config, options) {
+    const resourceParams = createResourceParams$C(config);
+    const request = createResourceRequest$C(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$v(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$x(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$A(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$C(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -256,16 +256,16 @@ function buildNetworkSnapshot$A(luvio, config, options) {
 }
 const publishAdapterFactory = (luvio) => {
     return function publish(untrustedConfig) {
-        const config = validateAdapterConfig$A(untrustedConfig, publish_ConfigPropertyNames);
+        const config = validateAdapterConfig$C(untrustedConfig, publish_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "publish"');
         }
-        return buildNetworkSnapshot$A(luvio, config);
+        return buildNetworkSnapshot$C(luvio, config);
     };
 };
 
-function validate$G(obj, path = 'DashboardAnnotationAnchorRepresentation') {
+function validate$J(obj, path = 'DashboardAnnotationAnchorRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -279,7 +279,7 @@ function validate$G(obj, path = 'DashboardAnnotationAnchorRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$F(obj, path = 'AnnotationAssetRepresentation') {
+function validate$I(obj, path = 'AnnotationAssetRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -298,7 +298,7 @@ function validate$F(obj, path = 'AnnotationAssetRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$E(obj, path = 'FileTypeOutputRepresentation') {
+function validate$H(obj, path = 'FileTypeOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -317,7 +317,7 @@ function validate$E(obj, path = 'FileTypeOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$D(obj, path = 'ContentVersionOutputRepresentation') {
+function validate$G(obj, path = 'ContentVersionOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -331,7 +331,7 @@ function validate$D(obj, path = 'ContentVersionOutputRepresentation') {
         const path_filetype = path + '.filetype';
         let obj_filetype_union0 = null;
         const obj_filetype_union0_error = (() => {
-            const referencepath_filetypeValidationError = validate$E(obj_filetype, path_filetype);
+            const referencepath_filetypeValidationError = validate$H(obj_filetype, path_filetype);
             if (referencepath_filetypeValidationError !== null) {
                 let message = 'Object doesn\'t match FileTypeOutputRepresentation (at "' + path_filetype + '")\n';
                 message += referencepath_filetypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -401,14 +401,14 @@ function validate$D(obj, path = 'ContentVersionOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$C(obj, path = 'ContentDocumentOutputRepresentation') {
+function validate$F(obj, path = 'ContentDocumentOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
         const obj_filetype = obj.filetype;
         const path_filetype = path + '.filetype';
-        const referencepath_filetypeValidationError = validate$E(obj_filetype, path_filetype);
+        const referencepath_filetypeValidationError = validate$H(obj_filetype, path_filetype);
         if (referencepath_filetypeValidationError !== null) {
             let message = 'Object doesn\'t match FileTypeOutputRepresentation (at "' + path_filetype + '")\n';
             message += referencepath_filetypeValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -421,7 +421,7 @@ function validate$C(obj, path = 'ContentDocumentOutputRepresentation') {
         }
         const obj_latestPublishedVersion = obj.latestPublishedVersion;
         const path_latestPublishedVersion = path + '.latestPublishedVersion';
-        const referencepath_latestPublishedVersionValidationError = validate$D(obj_latestPublishedVersion, path_latestPublishedVersion);
+        const referencepath_latestPublishedVersionValidationError = validate$G(obj_latestPublishedVersion, path_latestPublishedVersion);
         if (referencepath_latestPublishedVersionValidationError !== null) {
             let message = 'Object doesn\'t match ContentVersionOutputRepresentation (at "' + path_latestPublishedVersion + '")\n';
             message += referencepath_latestPublishedVersionValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -441,7 +441,7 @@ function validate$C(obj, path = 'ContentDocumentOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$B(obj, path = 'SlackFileOutputRepresentation') {
+function validate$E(obj, path = 'SlackFileOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -450,7 +450,7 @@ function validate$B(obj, path = 'SlackFileOutputRepresentation') {
         const path_contentDocument = path + '.contentDocument';
         let obj_contentDocument_union0 = null;
         const obj_contentDocument_union0_error = (() => {
-            const referencepath_contentDocumentValidationError = validate$C(obj_contentDocument, path_contentDocument);
+            const referencepath_contentDocumentValidationError = validate$F(obj_contentDocument, path_contentDocument);
             if (referencepath_contentDocumentValidationError !== null) {
                 let message = 'Object doesn\'t match ContentDocumentOutputRepresentation (at "' + path_contentDocument + '")\n';
                 message += referencepath_contentDocumentValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -550,7 +550,7 @@ function validate$B(obj, path = 'SlackFileOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$A(obj, path = 'SlackEmojiOutputRepresentation') {
+function validate$D(obj, path = 'SlackEmojiOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -674,7 +674,7 @@ function validate$A(obj, path = 'SlackEmojiOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$z(obj, path = 'SlackUserInfoOutputRepresentation') {
+function validate$C(obj, path = 'SlackUserInfoOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1001,7 +1001,7 @@ function validate$z(obj, path = 'SlackUserInfoOutputRepresentation') {
             const path_statusEmoji = path + '.statusEmoji';
             let obj_statusEmoji_union0 = null;
             const obj_statusEmoji_union0_error = (() => {
-                const referencepath_statusEmojiValidationError = validate$A(obj_statusEmoji, path_statusEmoji);
+                const referencepath_statusEmojiValidationError = validate$D(obj_statusEmoji, path_statusEmoji);
                 if (referencepath_statusEmojiValidationError !== null) {
                     let message = 'Object doesn\'t match SlackEmojiOutputRepresentation (at "' + path_statusEmoji + '")\n';
                     message += referencepath_statusEmojiValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1064,7 +1064,7 @@ function validate$z(obj, path = 'SlackUserInfoOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$y(obj, path = 'SlackReactionOutputRepresentation') {
+function validate$B(obj, path = 'SlackReactionOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1144,7 +1144,7 @@ function validate$y(obj, path = 'SlackReactionOutputRepresentation') {
         for (let i = 0; i < obj_reactedUsers.length; i++) {
             const obj_reactedUsers_item = obj_reactedUsers[i];
             const path_reactedUsers_item = path_reactedUsers + '[' + i + ']';
-            const referencepath_reactedUsers_itemValidationError = validate$z(obj_reactedUsers_item, path_reactedUsers_item);
+            const referencepath_reactedUsers_itemValidationError = validate$C(obj_reactedUsers_item, path_reactedUsers_item);
             if (referencepath_reactedUsers_itemValidationError !== null) {
                 let message = 'Object doesn\'t match SlackUserInfoOutputRepresentation (at "' + path_reactedUsers_item + '")\n';
                 message += referencepath_reactedUsers_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1233,7 +1233,7 @@ function validate$y(obj, path = 'SlackReactionOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$x(obj, path = 'SlackMessageOutputRepresentation') {
+function validate$A(obj, path = 'SlackMessageOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1282,7 +1282,7 @@ function validate$x(obj, path = 'SlackMessageOutputRepresentation') {
         for (let i = 0; i < obj_files.length; i++) {
             const obj_files_item = obj_files[i];
             const path_files_item = path_files + '[' + i + ']';
-            const referencepath_files_itemValidationError = validate$B(obj_files_item, path_files_item);
+            const referencepath_files_itemValidationError = validate$E(obj_files_item, path_files_item);
             if (referencepath_files_itemValidationError !== null) {
                 let message = 'Object doesn\'t match SlackFileOutputRepresentation (at "' + path_files_item + '")\n';
                 message += referencepath_files_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1380,7 +1380,7 @@ function validate$x(obj, path = 'SlackMessageOutputRepresentation') {
         for (let i = 0; i < obj_reactions.length; i++) {
             const obj_reactions_item = obj_reactions[i];
             const path_reactions_item = path_reactions + '[' + i + ']';
-            const referencepath_reactions_itemValidationError = validate$y(obj_reactions_item, path_reactions_item);
+            const referencepath_reactions_itemValidationError = validate$B(obj_reactions_item, path_reactions_item);
             if (referencepath_reactions_itemValidationError !== null) {
                 let message = 'Object doesn\'t match SlackReactionOutputRepresentation (at "' + path_reactions_item + '")\n';
                 message += referencepath_reactions_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1421,7 +1421,7 @@ function validate$x(obj, path = 'SlackMessageOutputRepresentation') {
         for (let i = 0; i < obj_replyUsers.length; i++) {
             const obj_replyUsers_item = obj_replyUsers[i];
             const path_replyUsers_item = path_replyUsers + '[' + i + ']';
-            const referencepath_replyUsers_itemValidationError = validate$z(obj_replyUsers_item, path_replyUsers_item);
+            const referencepath_replyUsers_itemValidationError = validate$C(obj_replyUsers_item, path_replyUsers_item);
             if (referencepath_replyUsers_itemValidationError !== null) {
                 let message = 'Object doesn\'t match SlackUserInfoOutputRepresentation (at "' + path_replyUsers_item + '")\n';
                 message += referencepath_replyUsers_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1533,7 +1533,7 @@ function validate$x(obj, path = 'SlackMessageOutputRepresentation') {
         }
         const obj_userInfo = obj.userInfo;
         const path_userInfo = path + '.userInfo';
-        const referencepath_userInfoValidationError = validate$z(obj_userInfo, path_userInfo);
+        const referencepath_userInfoValidationError = validate$C(obj_userInfo, path_userInfo);
         if (referencepath_userInfoValidationError !== null) {
             let message = 'Object doesn\'t match SlackUserInfoOutputRepresentation (at "' + path_userInfo + '")\n';
             message += referencepath_userInfoValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1543,7 +1543,7 @@ function validate$x(obj, path = 'SlackMessageOutputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$w(obj, path = 'AnnotationConversationRepresentation') {
+function validate$z(obj, path = 'AnnotationConversationRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1568,7 +1568,7 @@ function validate$w(obj, path = 'AnnotationConversationRepresentation') {
             const path_message = path + '.message';
             let obj_message_union0 = null;
             const obj_message_union0_error = (() => {
-                const referencepath_messageValidationError = validate$x(obj_message, path_message);
+                const referencepath_messageValidationError = validate$A(obj_message, path_message);
                 if (referencepath_messageValidationError !== null) {
                     let message = 'Object doesn\'t match SlackMessageOutputRepresentation (at "' + path_message + '")\n';
                     message += referencepath_messageValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1603,9 +1603,9 @@ function validate$w(obj, path = 'AnnotationConversationRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$d = 1000;
-const VERSION$n = "bacc25da56cffff8126d9bdafc471a37";
-function validate$v(obj, path = 'AnnotationRepresentation') {
+const TTL$f = 1000;
+const VERSION$p = "bacc25da56cffff8126d9bdafc471a37";
+function validate$y(obj, path = 'AnnotationRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1613,7 +1613,7 @@ function validate$v(obj, path = 'AnnotationRepresentation') {
         if (obj.anchor !== undefined) {
             const obj_anchor = obj.anchor;
             const path_anchor = path + '.anchor';
-            const referencepath_anchorValidationError = validate$G(obj_anchor, path_anchor);
+            const referencepath_anchorValidationError = validate$J(obj_anchor, path_anchor);
             if (referencepath_anchorValidationError !== null) {
                 let message = 'Object doesn\'t match DashboardAnnotationAnchorRepresentation (at "' + path_anchor + '")\n';
                 message += referencepath_anchorValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1627,7 +1627,7 @@ function validate$v(obj, path = 'AnnotationRepresentation') {
         }
         const obj_asset = obj.asset;
         const path_asset = path + '.asset';
-        const referencepath_assetValidationError = validate$F(obj_asset, path_asset);
+        const referencepath_assetValidationError = validate$I(obj_asset, path_asset);
         if (referencepath_assetValidationError !== null) {
             let message = 'Object doesn\'t match AnnotationAssetRepresentation (at "' + path_asset + '")\n';
             message += referencepath_assetValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1635,7 +1635,7 @@ function validate$v(obj, path = 'AnnotationRepresentation') {
         }
         const obj_collaborationObject = obj.collaborationObject;
         const path_collaborationObject = path + '.collaborationObject';
-        const referencepath_collaborationObjectValidationError = validate$w(obj_collaborationObject, path_collaborationObject);
+        const referencepath_collaborationObjectValidationError = validate$z(obj_collaborationObject, path_collaborationObject);
         if (referencepath_collaborationObjectValidationError !== null) {
             let message = 'Object doesn\'t match AnnotationConversationRepresentation (at "' + path_collaborationObject + '")\n';
             message += referencepath_collaborationObjectValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -1654,58 +1654,58 @@ function validate$v(obj, path = 'AnnotationRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$o = 'AnnotationRepresentation';
-function keyBuilder$N(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$o + ':' + config.id;
+const RepresentationType$q = 'AnnotationRepresentation';
+function keyBuilder$R(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$q + ':' + config.id;
 }
 function keyBuilderFromType$d(luvio, object) {
     const keyParams = {
         id: object.id
     };
-    return keyBuilder$N(luvio, keyParams);
+    return keyBuilder$R(luvio, keyParams);
 }
-function normalize$n(input, existing, path, luvio, store, timestamp) {
+function normalize$p(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$S = function AnnotationRepresentationSelect() {
+const select$W = function AnnotationRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$n,
+        version: VERSION$p,
         private: [],
         opaque: true
     };
 };
-function equals$n(existing, incoming) {
+function equals$p(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$n = function AnnotationRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$p = function AnnotationRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$v(input);
+        const validateError = validate$y(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$d(luvio, input);
-    const ttlToUse = TTL$d;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$n, "UnifiedAnalytics", VERSION$n, RepresentationType$o, equals$n);
+    const ttlToUse = TTL$f;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$p, "UnifiedAnalytics", VERSION$p, RepresentationType$q, equals$p);
     return createLink(key);
 };
-function getTypeCacheKeys$n(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$p(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = keyBuilderFromType$d(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$o,
+        representationName: RepresentationType$q,
         mergeable: false
     });
 }
 
-const TTL$c = 1000;
-const VERSION$m = "a80c8e970184cc7789e13f69392d6203";
-function validate$u(obj, path = 'AnnotationCollectionRepresentation') {
+const TTL$e = 1000;
+const VERSION$o = "a80c8e970184cc7789e13f69392d6203";
+function validate$x(obj, path = 'AnnotationCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -1730,14 +1730,14 @@ function validate$u(obj, path = 'AnnotationCollectionRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$n = 'AnnotationCollectionRepresentation';
-function normalize$m(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$p = 'AnnotationCollectionRepresentation';
+function normalize$o(input, existing, path, luvio, store, timestamp) {
     const input_annotations = input.annotations;
     const input_annotations_id = path.fullPath + '__annotations';
     for (let i = 0; i < input_annotations.length; i++) {
         const input_annotations_item = input_annotations[i];
         let input_annotations_item_id = input_annotations_id + '__' + i;
-        input_annotations[i] = ingest$n(input_annotations_item, {
+        input_annotations[i] = ingest$p(input_annotations_item, {
             fullPath: input_annotations_item_id,
             propertyName: i,
             parent: {
@@ -1750,17 +1750,17 @@ function normalize$m(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$R = function AnnotationCollectionRepresentationSelect() {
+const select$V = function AnnotationCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$m,
+        version: VERSION$o,
         private: [],
         selections: [
             {
                 name: 'annotations',
                 kind: 'Link',
                 plural: true,
-                fragment: select$S()
+                fragment: select$W()
             },
             {
                 name: 'total',
@@ -1769,7 +1769,7 @@ const select$R = function AnnotationCollectionRepresentationSelect() {
         ]
     };
 };
-function equals$m(existing, incoming) {
+function equals$o(existing, incoming) {
     const existing_total = existing.total;
     const incoming_total = incoming.total;
     if (!(existing_total === incoming_total)) {
@@ -1787,48 +1787,48 @@ function equals$m(existing, incoming) {
     }
     return true;
 }
-const ingest$m = function AnnotationCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$o = function AnnotationCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$u(input);
+        const validateError = validate$x(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$c;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$m, "UnifiedAnalytics", VERSION$m, RepresentationType$n, equals$m);
+    const ttlToUse = TTL$e;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$o, "UnifiedAnalytics", VERSION$o, RepresentationType$p, equals$o);
     return createLink(key);
 };
-function getTypeCacheKeys$m(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$o(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$n,
+        representationName: RepresentationType$p,
         mergeable: false
     });
     const input_annotations_length = input.annotations.length;
     for (let i = 0; i < input_annotations_length; i++) {
-        getTypeCacheKeys$n(rootKeySet, luvio, input.annotations[i]);
+        getTypeCacheKeys$p(rootKeySet, luvio, input.annotations[i]);
     }
 }
 
-function select$Q(luvio, params) {
-    return select$R();
+function select$U(luvio, params) {
+    return select$V();
 }
-function keyBuilder$M(luvio, params) {
+function keyBuilder$Q(luvio, params) {
     return keyPrefix + '::AnnotationCollectionRepresentation:(' + 'assetIds:' + params.queryParams.assetIds + ',' + 'includeTopMessage:' + params.queryParams.includeTopMessage + ',' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ',' + 'slackAppId:' + params.queryParams.slackAppId + ')';
 }
-function getResponseCacheKeys$z(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$m(storeKeyMap, luvio, response, () => keyBuilder$M(luvio, resourceParams));
+function getResponseCacheKeys$B(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$o(storeKeyMap, luvio, response, () => keyBuilder$Q(luvio, resourceParams));
 }
-function ingestSuccess$u(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$w(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$M(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$m, body);
+    const key = keyBuilder$Q(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$o, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$Q(),
+        node: select$U(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -1839,23 +1839,23 @@ function ingestSuccess$u(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$e(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$M(luvio, params);
+function ingestError$g(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$Q(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$c,
+        ttl: TTL$e,
         namespace: keyPrefix,
-        version: VERSION$m,
-        representationName: RepresentationType$n
+        version: VERSION$o,
+        representationName: RepresentationType$p
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$z(config) {
+function createResourceRequest$B(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/annotations',
+        basePath: '/tableau/annotations',
         method: 'get',
         body: null,
         urlParams: {},
@@ -1865,7 +1865,7 @@ function createResourceRequest$z(config) {
     };
 }
 
-const adapterName$z = 'getAnnotations';
+const adapterName$B = 'getAnnotations';
 const getAnnotations_ConfigPropertyMetadata = [
     generateParamConfigMetadata('assetIds', false, 1 /* QueryParameter */, 0 /* String */, true),
     generateParamConfigMetadata('includeTopMessage', false, 1 /* QueryParameter */, 1 /* Boolean */),
@@ -1873,101 +1873,101 @@ const getAnnotations_ConfigPropertyMetadata = [
     generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('slackAppId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getAnnotations_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$z, getAnnotations_ConfigPropertyMetadata);
-const createResourceParams$z = /*#__PURE__*/ createResourceParams$B(getAnnotations_ConfigPropertyMetadata);
-function keyBuilder$L(luvio, config) {
-    const resourceParams = createResourceParams$z(config);
-    return keyBuilder$M(luvio, resourceParams);
+const getAnnotations_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$B, getAnnotations_ConfigPropertyMetadata);
+const createResourceParams$B = /*#__PURE__*/ createResourceParams$D(getAnnotations_ConfigPropertyMetadata);
+function keyBuilder$P(luvio, config) {
+    const resourceParams = createResourceParams$B(config);
+    return keyBuilder$Q(luvio, resourceParams);
 }
-function typeCheckConfig$z(untrustedConfig) {
+function typeCheckConfig$B(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getAnnotations_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getAnnotations_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$z(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$B(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$z(untrustedConfig);
+    const config = typeCheckConfig$B(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$e(luvio, config) {
-    createResourceParams$z(config);
-    return select$Q();
+function adapterFragment$g(luvio, config) {
+    createResourceParams$B(config);
+    return select$U();
 }
-function onFetchResponseSuccess$e(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$u(luvio, resourceParams, response, {
+function onFetchResponseSuccess$g(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$w(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$e(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$e(luvio, resourceParams, response, {
+function onFetchResponseError$g(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$g(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$z(luvio, config, options) {
-    const resourceParams = createResourceParams$z(config);
-    const request = createResourceRequest$z(resourceParams);
+function buildNetworkSnapshot$B(luvio, config, options) {
+    const resourceParams = createResourceParams$B(config);
+    const request = createResourceRequest$B(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$e(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$g(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$z(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$B(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$e(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$g(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$e(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$z, undefined, false);
+function buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$B, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$L(luvio, config),
-        node: adapterFragment$e(luvio, config),
+        recordId: keyBuilder$P(luvio, config),
+        node: adapterFragment$g(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getAnnotationsAdapterFactory = (luvio) => function UnifiedAnalytics__getAnnotations(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$z(untrustedConfig, getAnnotations_ConfigPropertyNames);
+    const config = validateAdapterConfig$B(untrustedConfig, getAnnotations_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$e, buildNetworkSnapshotCachePolicy$e);
+    buildCachedSnapshotCachePolicy$g, buildNetworkSnapshotCachePolicy$g);
 };
 
-function select$P(luvio, params) {
-    return select$S();
+function select$T(luvio, params) {
+    return select$W();
 }
-function getResponseCacheKeys$y(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$n(storeKeyMap, luvio, response);
+function getResponseCacheKeys$A(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$p(storeKeyMap, luvio, response);
 }
-function ingestSuccess$t(luvio, resourceParams, response) {
+function ingestSuccess$v(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$d(luvio, body);
-    luvio.storeIngest(key, ingest$n, body);
+    luvio.storeIngest(key, ingest$p, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$P(),
+        node: select$T(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1978,11 +1978,11 @@ function ingestSuccess$t(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$y(config) {
+function createResourceRequest$A(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/annotations',
+        basePath: '/tableau/annotations',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -1992,7 +1992,7 @@ function createResourceRequest$y(config) {
     };
 }
 
-const adapterName$y = 'createAnnotation';
+const adapterName$A = 'createAnnotation';
 const createAnnotation_ConfigPropertyMetadata = [
     generateParamConfigMetadata('anchor', false, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('annotationTool', true, 2 /* Body */, 0 /* String */),
@@ -2001,41 +2001,41 @@ const createAnnotation_ConfigPropertyMetadata = [
     generateParamConfigMetadata('collaborationObject', true, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('status', true, 2 /* Body */, 0 /* String */),
 ];
-const createAnnotation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$y, createAnnotation_ConfigPropertyMetadata);
-const createResourceParams$y = /*#__PURE__*/ createResourceParams$B(createAnnotation_ConfigPropertyMetadata);
-function typeCheckConfig$y(untrustedConfig) {
+const createAnnotation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$A, createAnnotation_ConfigPropertyMetadata);
+const createResourceParams$A = /*#__PURE__*/ createResourceParams$D(createAnnotation_ConfigPropertyMetadata);
+function typeCheckConfig$A(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, createAnnotation_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, createAnnotation_ConfigPropertyMetadata);
     const untrustedConfig_anchor = untrustedConfig.anchor;
     config.anchor = untrustedConfig_anchor;
     const untrustedConfig_collaborationObject = untrustedConfig.collaborationObject;
     config.collaborationObject = untrustedConfig_collaborationObject;
     return config;
 }
-function validateAdapterConfig$y(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$A(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$y(untrustedConfig);
+    const config = typeCheckConfig$A(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$y(luvio, config, options) {
-    const resourceParams = createResourceParams$y(config);
-    const request = createResourceRequest$y(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(() => {
-            const snapshot = ingestSuccess$t(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$v(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$y(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$A(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2045,18 +2045,18 @@ function buildNetworkSnapshot$y(luvio, config, options) {
 }
 const createAnnotationAdapterFactory = (luvio) => {
     return function createAnnotation(untrustedConfig) {
-        const config = validateAdapterConfig$y(untrustedConfig, createAnnotation_ConfigPropertyNames);
+        const config = validateAdapterConfig$A(untrustedConfig, createAnnotation_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createAnnotation"');
         }
-        return buildNetworkSnapshot$y(luvio, config);
+        return buildNetworkSnapshot$A(luvio, config);
     };
 };
 
-const TTL$b = 5000;
-const VERSION$l = "505a83d97fefa7ce68ec6512264b0543";
-function validate$t(obj, path = 'SlackAppInfoRepresentation') {
+const TTL$d = 5000;
+const VERSION$n = "505a83d97fefa7ce68ec6512264b0543";
+function validate$w(obj, path = 'SlackAppInfoRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -2096,14 +2096,14 @@ function validate$t(obj, path = 'SlackAppInfoRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$m = 'SlackAppInfoRepresentation';
-function normalize$l(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$o = 'SlackAppInfoRepresentation';
+function normalize$n(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$O = function SlackAppInfoRepresentationSelect() {
+const select$S = function SlackAppInfoRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$l,
+        version: VERSION$n,
         private: [],
         selections: [
             {
@@ -2130,7 +2130,7 @@ const select$O = function SlackAppInfoRepresentationSelect() {
         ]
     };
 };
-function equals$l(existing, incoming) {
+function equals$n(existing, incoming) {
     const existing_isSlackAppAuthorized = existing.isSlackAppAuthorized;
     const incoming_isSlackAppAuthorized = incoming.isSlackAppAuthorized;
     if (!(existing_isSlackAppAuthorized === incoming_isSlackAppAuthorized)) {
@@ -2163,44 +2163,44 @@ function equals$l(existing, incoming) {
     }
     return true;
 }
-const ingest$l = function SlackAppInfoRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$n = function SlackAppInfoRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$t(input);
+        const validateError = validate$w(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
-    const ttlToUse = TTL$b;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "UnifiedAnalytics", VERSION$l, RepresentationType$m, equals$l);
+    const ttlToUse = TTL$d;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$n, "UnifiedAnalytics", VERSION$n, RepresentationType$o, equals$n);
     return createLink(key);
 };
-function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$n(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$m,
+        representationName: RepresentationType$o,
         mergeable: false
     });
 }
 
-function select$N(luvio, params) {
-    return select$O();
+function select$R(luvio, params) {
+    return select$S();
 }
-function keyBuilder$K(luvio, params) {
+function keyBuilder$O(luvio, params) {
     return keyPrefix + '::SlackAppInfoRepresentation:(' + ')';
 }
-function getResponseCacheKeys$x(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$l(storeKeyMap, luvio, response, () => keyBuilder$K());
+function getResponseCacheKeys$z(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$n(storeKeyMap, luvio, response, () => keyBuilder$O());
 }
-function ingestSuccess$s(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$u(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$K();
-    luvio.storeIngest(key, ingest$l, body);
+    const key = keyBuilder$O();
+    luvio.storeIngest(key, ingest$n, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$N(),
+        node: select$R(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2211,23 +2211,23 @@ function ingestSuccess$s(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$d(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$K();
+function ingestError$f(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$O();
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
-        ttl: TTL$b,
+        ttl: TTL$d,
         namespace: keyPrefix,
-        version: VERSION$l,
-        representationName: RepresentationType$m
+        version: VERSION$n,
+        representationName: RepresentationType$o
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$x(config) {
+function createResourceRequest$z(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/annotations/slack-app-info',
+        basePath: '/tableau/annotations/slack-app-info',
         method: 'get',
         body: null,
         urlParams: {},
@@ -2237,90 +2237,90 @@ function createResourceRequest$x(config) {
     };
 }
 
-const adapterName$x = 'getSlackAppInfo';
+const adapterName$z = 'getSlackAppInfo';
 const getSlackAppInfo_ConfigPropertyMetadata = [];
-const getSlackAppInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$x, getSlackAppInfo_ConfigPropertyMetadata);
-const createResourceParams$x = /*#__PURE__*/ createResourceParams$B(getSlackAppInfo_ConfigPropertyMetadata);
-function keyBuilder$J(luvio, config) {
-    createResourceParams$x(config);
-    return keyBuilder$K();
+const getSlackAppInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$z, getSlackAppInfo_ConfigPropertyMetadata);
+const createResourceParams$z = /*#__PURE__*/ createResourceParams$D(getSlackAppInfo_ConfigPropertyMetadata);
+function keyBuilder$N(luvio, config) {
+    createResourceParams$z(config);
+    return keyBuilder$O();
 }
-function typeCheckConfig$x(untrustedConfig) {
+function typeCheckConfig$z(untrustedConfig) {
     const config = {};
     return config;
 }
-function validateAdapterConfig$x(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$z(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$x();
+    const config = typeCheckConfig$z();
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$d(luvio, config) {
-    createResourceParams$x(config);
-    return select$N();
+function adapterFragment$f(luvio, config) {
+    createResourceParams$z(config);
+    return select$R();
 }
-function onFetchResponseSuccess$d(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$s(luvio, resourceParams, response, {
+function onFetchResponseSuccess$f(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$u(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$d(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$d(luvio, resourceParams, response, {
+function onFetchResponseError$f(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$f(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$x(luvio, config, options) {
-    const resourceParams = createResourceParams$x(config);
-    const request = createResourceRequest$x();
+function buildNetworkSnapshot$z(luvio, config, options) {
+    const resourceParams = createResourceParams$z(config);
+    const request = createResourceRequest$z();
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$d(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$f(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$x(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$z(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$d(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$f(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$d(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$x, undefined, false);
+function buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$z, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$J(luvio, config),
-        node: adapterFragment$d(luvio, config),
+        recordId: keyBuilder$N(luvio, config),
+        node: adapterFragment$f(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSlackAppInfoAdapterFactory = (luvio) => function UnifiedAnalytics__getSlackAppInfo(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$x(untrustedConfig, getSlackAppInfo_ConfigPropertyNames);
+    const config = validateAdapterConfig$z(untrustedConfig, getSlackAppInfo_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$d, buildNetworkSnapshotCachePolicy$d);
+    buildCachedSnapshotCachePolicy$f, buildNetworkSnapshotCachePolicy$f);
 };
 
-function validate$s(obj, path = 'BaseAnalyticsRepresentation') {
+function validate$v(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 + '")');
@@ -2355,8 +2355,8 @@ function validate$s(obj, path = 'BaseAnalyticsRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-function validate$r(obj, path = 'AnalyticsAssetsQueryResultsWorkspaceRepresentation') {
-    const validateBaseAnalyticsRepresentation_validateError = validate$s(obj, path);
+function validate$u(obj, path = 'AnalyticsAssetsQueryResultsWorkspaceRepresentation') {
+    const validateBaseAnalyticsRepresentation_validateError = validate$v(obj, path);
     if (validateBaseAnalyticsRepresentation_validateError !== null) {
         return validateBaseAnalyticsRepresentation_validateError;
     }
@@ -2368,8 +2368,8 @@ function validate$r(obj, path = 'AnalyticsAssetsQueryResultsWorkspaceRepresentat
     return v_error === undefined ? null : v_error;
 }
 
-function validate$q(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation') {
-    const validateBaseAnalyticsRepresentation_validateError = validate$s(obj, path);
+function validate$t(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation') {
+    const validateBaseAnalyticsRepresentation_validateError = validate$v(obj, path);
     if (validateBaseAnalyticsRepresentation_validateError !== null) {
         return validateBaseAnalyticsRepresentation_validateError;
     }
@@ -2410,7 +2410,7 @@ function validate$q(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation')
             const path_workspace = path + '.workspace';
             let obj_workspace_union0 = null;
             const obj_workspace_union0_error = (() => {
-                const referencepath_workspaceValidationError = validate$r(obj_workspace, path_workspace);
+                const referencepath_workspaceValidationError = validate$u(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');
@@ -2440,9 +2440,9 @@ function validate$q(obj, path = 'AnalyticsAssetsQueryResultsItemRepresentation')
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$a = 500;
-const VERSION$k = "ed60d9cca169a3e5ed897c67d11a23db";
-function validate$p(obj, path = 'AnalyticsAssetsQueryResultsRepresentation') {
+const TTL$c = 500;
+const VERSION$m = "ed60d9cca169a3e5ed897c67d11a23db";
+function validate$s(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 + '")');
@@ -2455,7 +2455,7 @@ function validate$p(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$q(obj_items_item, path_items_item);
+            const referencepath_items_itemValidationError = validate$t(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');
@@ -2480,68 +2480,68 @@ function validate$p(obj, path = 'AnalyticsAssetsQueryResultsRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$l = 'AnalyticsAssetsQueryResultsRepresentation';
-function keyBuilder$I(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$l + ':' + config.searchId;
+const RepresentationType$n = 'AnalyticsAssetsQueryResultsRepresentation';
+function keyBuilder$M(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$n + ':' + config.searchId;
 }
 function keyBuilderFromType$c(luvio, object) {
     const keyParams = {
         searchId: object.queryKey
     };
-    return keyBuilder$I(luvio, keyParams);
+    return keyBuilder$M(luvio, keyParams);
 }
-function normalize$k(input, existing, path, luvio, store, timestamp) {
+function normalize$m(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$M = function AnalyticsAssetsQueryResultsRepresentationSelect() {
+const select$Q = function AnalyticsAssetsQueryResultsRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$k,
+        version: VERSION$m,
         private: [],
         opaque: true
     };
 };
-function equals$k(existing, incoming) {
+function equals$m(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$k = function AnalyticsAssetsQueryResultsRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$m = function AnalyticsAssetsQueryResultsRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$p(input);
+        const validateError = validate$s(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$c(luvio, input);
-    const ttlToUse = TTL$a;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "UnifiedAnalytics", VERSION$k, RepresentationType$l, equals$k);
+    const ttlToUse = TTL$c;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$m, "UnifiedAnalytics", VERSION$m, RepresentationType$n, equals$m);
     return createLink(key);
 };
-function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$m(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = keyBuilderFromType$c(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$l,
+        representationName: RepresentationType$n,
         mergeable: false
     });
 }
 
-function select$L(luvio, params) {
-    return select$M();
+function select$P(luvio, params) {
+    return select$Q();
 }
-function getResponseCacheKeys$w(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$k(storeKeyMap, luvio, response);
+function getResponseCacheKeys$y(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$m(storeKeyMap, luvio, response);
 }
-function ingestSuccess$r(luvio, resourceParams, response) {
+function ingestSuccess$t(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$c(luvio, body);
-    luvio.storeIngest(key, ingest$k, body);
+    luvio.storeIngest(key, ingest$m, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$L(),
+        node: select$P(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -2552,11 +2552,11 @@ function ingestSuccess$r(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$w(config) {
+function createResourceRequest$y(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/assets/query',
+        basePath: '/tableau/assets/query',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -2566,7 +2566,7 @@ function createResourceRequest$w(config) {
     };
 }
 
-const adapterName$w = 'queryAssets';
+const adapterName$y = 'queryAssets';
 const queryAssets_ConfigPropertyMetadata = [
     generateParamConfigMetadata('filters', false, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('limit', false, 2 /* Body */, 3 /* Integer */),
@@ -2575,11 +2575,11 @@ const queryAssets_ConfigPropertyMetadata = [
     generateParamConfigMetadata('searchTerm', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('sortDirection', false, 2 /* Body */, 0 /* String */),
 ];
-const queryAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$w, queryAssets_ConfigPropertyMetadata);
-const createResourceParams$w = /*#__PURE__*/ createResourceParams$B(queryAssets_ConfigPropertyMetadata);
-function typeCheckConfig$w(untrustedConfig) {
+const queryAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$y, queryAssets_ConfigPropertyMetadata);
+const createResourceParams$y = /*#__PURE__*/ createResourceParams$D(queryAssets_ConfigPropertyMetadata);
+function typeCheckConfig$y(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, queryAssets_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, queryAssets_ConfigPropertyMetadata);
     const untrustedConfig_filters = untrustedConfig.filters;
     if (untrustedIsObject(untrustedConfig_filters)) {
         const untrustedConfig_filters_object = {};
@@ -2597,30 +2597,30 @@ function typeCheckConfig$w(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$w(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$y(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$w(untrustedConfig);
+    const config = typeCheckConfig$y(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$w(luvio, config, options) {
-    const resourceParams = createResourceParams$w(config);
-    const request = createResourceRequest$w(resourceParams);
+function buildNetworkSnapshot$y(luvio, config, options) {
+    const resourceParams = createResourceParams$y(config);
+    const request = createResourceRequest$y(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$r(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$t(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$w(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$y(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -2630,17 +2630,17 @@ function buildNetworkSnapshot$w(luvio, config, options) {
 }
 const queryAssetsAdapterFactory = (luvio) => {
     return function queryAssets(untrustedConfig) {
-        const config = validateAdapterConfig$w(untrustedConfig, queryAssets_ConfigPropertyNames);
+        const config = validateAdapterConfig$y(untrustedConfig, queryAssets_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "queryAssets"');
         }
-        return buildNetworkSnapshot$w(luvio, config);
+        return buildNetworkSnapshot$y(luvio, config);
     };
 };
 
-const VERSION$j = "d4e4a9f9b260b72ce8e09fac1746cd21";
-function validate$o(obj, path = 'DashboardRepresentation') {
+const VERSION$l = "d4e4a9f9b260b72ce8e09fac1746cd21";
+function validate$r(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 + '")');
@@ -2753,57 +2753,57 @@ function validate$o(obj, path = 'DashboardRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$k = 'DashboardRepresentation';
-function keyBuilder$H(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$k + ':' + config.name;
+const RepresentationType$m = 'DashboardRepresentation';
+function keyBuilder$L(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$m + ':' + config.name;
 }
 function keyBuilderFromType$b(luvio, object) {
     const keyParams = {
         name: object.cacheableKey
     };
-    return keyBuilder$H(luvio, keyParams);
+    return keyBuilder$L(luvio, keyParams);
 }
-function normalize$j(input, existing, path, luvio, store, timestamp) {
+function normalize$l(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$K = function DashboardRepresentationSelect() {
+const select$O = function DashboardRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$j,
+        version: VERSION$l,
         private: [],
         opaque: true
     };
 };
-function equals$j(existing, incoming) {
+function equals$l(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$j = function DashboardRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$l = function DashboardRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$o(input);
+        const validateError = validate$r(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$b(luvio, input);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 60000;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "UnifiedAnalytics", VERSION$j, RepresentationType$k, equals$j);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$l, "UnifiedAnalytics", VERSION$l, RepresentationType$m, equals$l);
     return createLink(key);
 };
-function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$l(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = keyBuilderFromType$b(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$k,
+        representationName: RepresentationType$m,
         mergeable: false
     });
 }
 
-const VERSION$i = "962823130e6a9315240ef0e0f0c5f757";
-function validate$n(obj, path = 'DashboardCollectionRepresentation') {
+const VERSION$k = "962823130e6a9315240ef0e0f0c5f757";
+function validate$q(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 + '")');
@@ -2823,14 +2823,14 @@ function validate$n(obj, path = 'DashboardCollectionRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$j = 'DashboardCollectionRepresentation';
-function normalize$i(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$l = 'DashboardCollectionRepresentation';
+function normalize$k(input, existing, path, luvio, store, timestamp) {
     const input_dashboards = input.dashboards;
     const input_dashboards_id = path.fullPath + '__dashboards';
     for (let i = 0; i < input_dashboards.length; i++) {
         const input_dashboards_item = input_dashboards[i];
         let input_dashboards_item_id = input_dashboards_id + '__' + i;
-        input_dashboards[i] = ingest$j(input_dashboards_item, {
+        input_dashboards[i] = ingest$l(input_dashboards_item, {
             fullPath: input_dashboards_item_id,
             propertyName: i,
             parent: {
@@ -2843,22 +2843,22 @@ function normalize$i(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$J = function DashboardCollectionRepresentationSelect() {
+const select$N = function DashboardCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$i,
+        version: VERSION$k,
         private: [],
         selections: [
             {
                 name: 'dashboards',
                 kind: 'Link',
                 plural: true,
-                fragment: select$K()
+                fragment: select$O()
             }
         ]
     };
 };
-function equals$i(existing, incoming) {
+function equals$k(existing, incoming) {
     const existing_dashboards = existing.dashboards;
     const incoming_dashboards = incoming.dashboards;
     const equals_dashboards_items = equalsArray(existing_dashboards, incoming_dashboards, (existing_dashboards_item, incoming_dashboards_item) => {
@@ -2871,48 +2871,48 @@ function equals$i(existing, incoming) {
     }
     return true;
 }
-const ingest$i = function DashboardCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$k = function DashboardCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$n(input);
+        const validateError = validate$q(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = path.fullPath;
     const ttlToUse = path.ttl !== undefined ? path.ttl : 60000;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "UnifiedAnalytics", VERSION$i, RepresentationType$j, equals$i);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$k, "UnifiedAnalytics", VERSION$k, RepresentationType$l, equals$k);
     return createLink(key);
 };
-function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$k(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$j,
+        representationName: RepresentationType$l,
         mergeable: false
     });
     const input_dashboards_length = input.dashboards.length;
     for (let i = 0; i < input_dashboards_length; i++) {
-        getTypeCacheKeys$j(rootKeySet, luvio, input.dashboards[i]);
+        getTypeCacheKeys$l(rootKeySet, luvio, input.dashboards[i]);
     }
 }
 
-function select$I(luvio, params) {
-    return select$J();
+function select$M(luvio, params) {
+    return select$N();
 }
-function keyBuilder$G(luvio, params) {
+function keyBuilder$K(luvio, params) {
     return keyPrefix + '::DashboardCollectionRepresentation:(' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ')';
 }
-function getResponseCacheKeys$v(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$i(storeKeyMap, luvio, response, () => keyBuilder$G(luvio, resourceParams));
+function getResponseCacheKeys$x(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$k(storeKeyMap, luvio, response, () => keyBuilder$K(luvio, resourceParams));
 }
-function ingestSuccess$q(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$s(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$G(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$i, body);
+    const key = keyBuilder$K(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$k, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$I(),
+        node: select$M(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -2923,17 +2923,17 @@ function ingestSuccess$q(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$c(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$G(luvio, params);
+function ingestError$e(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$K(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$v(config) {
+function createResourceRequest$x(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/dashboards',
+        basePath: '/tableau/dashboards',
         method: 'get',
         body: null,
         urlParams: {},
@@ -2943,106 +2943,106 @@ function createResourceRequest$v(config) {
     };
 }
 
-const adapterName$v = 'getDashboards';
+const adapterName$x = 'getDashboards';
 const getDashboards_ConfigPropertyMetadata = [
     generateParamConfigMetadata('limit', false, 1 /* QueryParameter */, 3 /* Integer */),
     generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
 ];
-const getDashboards_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$v, getDashboards_ConfigPropertyMetadata);
-const createResourceParams$v = /*#__PURE__*/ createResourceParams$B(getDashboards_ConfigPropertyMetadata);
-function keyBuilder$F(luvio, config) {
-    const resourceParams = createResourceParams$v(config);
-    return keyBuilder$G(luvio, resourceParams);
+const getDashboards_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$x, getDashboards_ConfigPropertyMetadata);
+const createResourceParams$x = /*#__PURE__*/ createResourceParams$D(getDashboards_ConfigPropertyMetadata);
+function keyBuilder$J(luvio, config) {
+    const resourceParams = createResourceParams$x(config);
+    return keyBuilder$K(luvio, resourceParams);
 }
-function typeCheckConfig$v(untrustedConfig) {
+function typeCheckConfig$x(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getDashboards_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getDashboards_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$v(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$x(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$v(untrustedConfig);
+    const config = typeCheckConfig$x(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$c(luvio, config) {
-    createResourceParams$v(config);
-    return select$I();
+function adapterFragment$e(luvio, config) {
+    createResourceParams$x(config);
+    return select$M();
 }
-function onFetchResponseSuccess$c(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$q(luvio, resourceParams, response, {
+function onFetchResponseSuccess$e(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$s(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$c(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$c(luvio, resourceParams, response, {
+function onFetchResponseError$e(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$e(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$v(luvio, config, options) {
-    const resourceParams = createResourceParams$v(config);
-    const request = createResourceRequest$v(resourceParams);
+function buildNetworkSnapshot$x(luvio, config, options) {
+    const resourceParams = createResourceParams$x(config);
+    const request = createResourceRequest$x(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$c(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$e(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$v(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$x(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$c(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$e(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$c(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$v, undefined, false);
+function buildNetworkSnapshotCachePolicy$e(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$x, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$F(luvio, config),
-        node: adapterFragment$c(luvio, config),
+        recordId: keyBuilder$J(luvio, config),
+        node: adapterFragment$e(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDashboardsAdapterFactory = (luvio) => function UnifiedAnalytics__getDashboards(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$v(untrustedConfig, getDashboards_ConfigPropertyNames);
+    const config = validateAdapterConfig$x(untrustedConfig, getDashboards_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$c, buildNetworkSnapshotCachePolicy$c);
+    buildCachedSnapshotCachePolicy$e, buildNetworkSnapshotCachePolicy$e);
 };
 
-function select$H(luvio, params) {
-    return select$K();
+function select$L(luvio, params) {
+    return select$O();
 }
-function getResponseCacheKeys$u(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$j(storeKeyMap, luvio, response);
+function getResponseCacheKeys$w(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$l(storeKeyMap, luvio, response);
 }
-function ingestSuccess$p(luvio, resourceParams, response) {
+function ingestSuccess$r(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$b(luvio, body);
-    luvio.storeIngest(key, ingest$j, body);
+    luvio.storeIngest(key, ingest$l, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$H(),
+        node: select$L(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3053,11 +3053,11 @@ function ingestSuccess$p(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$u(config) {
+function createResourceRequest$w(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/dashboards',
+        basePath: '/tableau/dashboards',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -3067,7 +3067,7 @@ function createResourceRequest$u(config) {
     };
 }
 
-const adapterName$u = 'createDashboard';
+const adapterName$w = 'createDashboard';
 const createDashboard_ConfigPropertyMetadata = [
     generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('id', false, 2 /* Body */, 0 /* String */),
@@ -3078,11 +3078,11 @@ const createDashboard_ConfigPropertyMetadata = [
     generateParamConfigMetadata('widgets', true, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('style', false, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, createDashboard_ConfigPropertyMetadata);
-const createResourceParams$u = /*#__PURE__*/ createResourceParams$B(createDashboard_ConfigPropertyMetadata);
-function typeCheckConfig$u(untrustedConfig) {
+const createDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$w, createDashboard_ConfigPropertyMetadata);
+const createResourceParams$w = /*#__PURE__*/ createResourceParams$D(createDashboard_ConfigPropertyMetadata);
+function typeCheckConfig$w(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, createDashboard_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, createDashboard_ConfigPropertyMetadata);
     const untrustedConfig_layouts = untrustedConfig.layouts;
     if (ArrayIsArray$1(untrustedConfig_layouts)) {
         const untrustedConfig_layouts_array = [];
@@ -3124,30 +3124,30 @@ function typeCheckConfig$u(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$u(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$w(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$u(untrustedConfig);
+    const config = typeCheckConfig$w(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$u(luvio, config, options) {
-    const resourceParams = createResourceParams$u(config);
-    const request = createResourceRequest$u(resourceParams);
+function buildNetworkSnapshot$w(luvio, config, options) {
+    const resourceParams = createResourceParams$w(config);
+    const request = createResourceRequest$w(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$p(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$r(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$u(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$w(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3157,37 +3157,37 @@ function buildNetworkSnapshot$u(luvio, config, options) {
 }
 const createDashboardAdapterFactory = (luvio) => {
     return function createDashboard(untrustedConfig) {
-        const config = validateAdapterConfig$u(untrustedConfig, createDashboard_ConfigPropertyNames);
+        const config = validateAdapterConfig$w(untrustedConfig, createDashboard_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "createDashboard"');
         }
-        return buildNetworkSnapshot$u(luvio, config);
+        return buildNetworkSnapshot$w(luvio, config);
     };
 };
 
-function keyBuilder$E(luvio, params) {
-    return keyBuilder$H(luvio, {
+function keyBuilder$I(luvio, params) {
+    return keyBuilder$L(luvio, {
         name: params.urlParams.dashboardIdOrApiName
     });
 }
-function getResponseCacheKeys$t(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$E(luvio, resourceParams);
+function getResponseCacheKeys$v(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$I(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$k,
+        representationName: RepresentationType$m,
         mergeable: false
     });
 }
 function evictSuccess$4(luvio, resourceParams) {
-    const key = keyBuilder$E(luvio, resourceParams);
+    const key = keyBuilder$I(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$t(config) {
+function createResourceRequest$v(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/dashboards/' + config.urlParams.dashboardIdOrApiName + '',
+        basePath: '/tableau/dashboards/' + config.urlParams.dashboardIdOrApiName + '',
         method: 'delete',
         body: null,
         urlParams: config.urlParams,
@@ -3197,33 +3197,33 @@ function createResourceRequest$t(config) {
     };
 }
 
-const adapterName$t = 'deleteDashboard';
+const adapterName$v = 'deleteDashboard';
 const deleteDashboard_ConfigPropertyMetadata = [
     generateParamConfigMetadata('dashboardIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const deleteDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, deleteDashboard_ConfigPropertyMetadata);
-const createResourceParams$t = /*#__PURE__*/ createResourceParams$B(deleteDashboard_ConfigPropertyMetadata);
-function typeCheckConfig$t(untrustedConfig) {
+const deleteDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$v, deleteDashboard_ConfigPropertyMetadata);
+const createResourceParams$v = /*#__PURE__*/ createResourceParams$D(deleteDashboard_ConfigPropertyMetadata);
+function typeCheckConfig$v(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, deleteDashboard_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, deleteDashboard_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$t(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$v(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$t(untrustedConfig);
+    const config = typeCheckConfig$v(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$t(luvio, config, options) {
-    const resourceParams = createResourceParams$t(config);
-    const request = createResourceRequest$t(resourceParams);
+function buildNetworkSnapshot$v(luvio, config, options) {
+    const resourceParams = createResourceParams$v(config);
+    const request = createResourceRequest$v(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -3231,7 +3231,7 @@ function buildNetworkSnapshot$t(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$t(cache, luvio, resourceParams);
+            getResponseCacheKeys$v(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -3241,33 +3241,33 @@ function buildNetworkSnapshot$t(luvio, config, options) {
 }
 const deleteDashboardAdapterFactory = (luvio) => {
     return function UnifiedAnalyticsdeleteDashboard(untrustedConfig) {
-        const config = validateAdapterConfig$t(untrustedConfig, deleteDashboard_ConfigPropertyNames);
+        const config = validateAdapterConfig$v(untrustedConfig, deleteDashboard_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$t}"`);
+            throw new Error(`Invalid config for "${adapterName$v}"`);
         }
-        return buildNetworkSnapshot$t(luvio, config);
+        return buildNetworkSnapshot$v(luvio, config);
     };
 };
 
-function select$G(luvio, params) {
-    return select$K();
+function select$K(luvio, params) {
+    return select$O();
 }
-function keyBuilder$D(luvio, params) {
-    return keyBuilder$H(luvio, {
+function keyBuilder$H(luvio, params) {
+    return keyBuilder$L(luvio, {
         name: params.urlParams.dashboardIdOrApiName
     });
 }
-function getResponseCacheKeys$s(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$j(storeKeyMap, luvio, response);
+function getResponseCacheKeys$u(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$l(storeKeyMap, luvio, response);
 }
-function ingestSuccess$o(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$q(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$D(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$j, body);
+    const key = keyBuilder$H(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$l, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$G(),
+        node: select$K(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3278,17 +3278,17 @@ function ingestSuccess$o(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$b(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$D(luvio, params);
+function ingestError$d(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$H(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$s(config) {
+function createResourceRequest$u(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/dashboards/' + config.urlParams.dashboardIdOrApiName + '',
+        basePath: '/tableau/dashboards/' + config.urlParams.dashboardIdOrApiName + '',
         method: 'get',
         body: null,
         urlParams: config.urlParams,
@@ -3298,105 +3298,105 @@ function createResourceRequest$s(config) {
     };
 }
 
-const adapterName$s = 'getDashboardByName';
+const adapterName$u = 'getDashboardByName';
 const getDashboardByName_ConfigPropertyMetadata = [
     generateParamConfigMetadata('dashboardIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const getDashboardByName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, getDashboardByName_ConfigPropertyMetadata);
-const createResourceParams$s = /*#__PURE__*/ createResourceParams$B(getDashboardByName_ConfigPropertyMetadata);
-function keyBuilder$C(luvio, config) {
-    const resourceParams = createResourceParams$s(config);
-    return keyBuilder$D(luvio, resourceParams);
+const getDashboardByName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$u, getDashboardByName_ConfigPropertyMetadata);
+const createResourceParams$u = /*#__PURE__*/ createResourceParams$D(getDashboardByName_ConfigPropertyMetadata);
+function keyBuilder$G(luvio, config) {
+    const resourceParams = createResourceParams$u(config);
+    return keyBuilder$H(luvio, resourceParams);
 }
-function typeCheckConfig$s(untrustedConfig) {
+function typeCheckConfig$u(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getDashboardByName_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getDashboardByName_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$s(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$u(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$s(untrustedConfig);
+    const config = typeCheckConfig$u(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$b(luvio, config) {
-    createResourceParams$s(config);
-    return select$G();
+function adapterFragment$d(luvio, config) {
+    createResourceParams$u(config);
+    return select$K();
 }
-function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$o(luvio, resourceParams, response, {
+function onFetchResponseSuccess$d(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$q(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$s(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$b(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$b(luvio, resourceParams, response, {
+function onFetchResponseError$d(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$d(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$s(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$s(luvio, config, options) {
-    const resourceParams = createResourceParams$s(config);
-    const request = createResourceRequest$s(resourceParams);
+function buildNetworkSnapshot$u(luvio, config, options) {
+    const resourceParams = createResourceParams$u(config);
+    const request = createResourceRequest$u(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$b(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$d(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$s(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$u(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$b(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$d(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$s, undefined, false);
+function buildNetworkSnapshotCachePolicy$d(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$u, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$C(luvio, config),
-        node: adapterFragment$b(luvio, config),
+        recordId: keyBuilder$G(luvio, config),
+        node: adapterFragment$d(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$s(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getDashboardByNameAdapterFactory = (luvio) => function UnifiedAnalytics__getDashboardByName(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$s(untrustedConfig, getDashboardByName_ConfigPropertyNames);
+    const config = validateAdapterConfig$u(untrustedConfig, getDashboardByName_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$b, buildNetworkSnapshotCachePolicy$b);
+    buildCachedSnapshotCachePolicy$d, buildNetworkSnapshotCachePolicy$d);
 };
 
-function select$F(luvio, params) {
-    return select$K();
+function select$J(luvio, params) {
+    return select$O();
 }
-function getResponseCacheKeys$r(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$j(storeKeyMap, luvio, response);
+function getResponseCacheKeys$t(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$l(storeKeyMap, luvio, response);
 }
-function ingestSuccess$n(luvio, resourceParams, response) {
+function ingestSuccess$p(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$b(luvio, body);
-    luvio.storeIngest(key, ingest$j, body);
+    luvio.storeIngest(key, ingest$l, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$F(),
+        node: select$J(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3407,11 +3407,11 @@ function ingestSuccess$n(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$r(config) {
+function createResourceRequest$t(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/dashboards/' + config.urlParams.dashboardIdOrApiName + '',
+        basePath: '/tableau/dashboards/' + config.urlParams.dashboardIdOrApiName + '',
         method: 'patch',
         body: config.body,
         urlParams: config.urlParams,
@@ -3421,7 +3421,7 @@ function createResourceRequest$r(config) {
     };
 }
 
-const adapterName$r = 'updateDashboard';
+const adapterName$t = 'updateDashboard';
 const updateDashboard_ConfigPropertyMetadata = [
     generateParamConfigMetadata('dashboardIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('description', false, 2 /* Body */, 0 /* String */),
@@ -3433,11 +3433,11 @@ const updateDashboard_ConfigPropertyMetadata = [
     generateParamConfigMetadata('widgets', true, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('style', false, 2 /* Body */, 4 /* Unsupported */),
 ];
-const updateDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$r, updateDashboard_ConfigPropertyMetadata);
-const createResourceParams$r = /*#__PURE__*/ createResourceParams$B(updateDashboard_ConfigPropertyMetadata);
-function typeCheckConfig$r(untrustedConfig) {
+const updateDashboard_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$t, updateDashboard_ConfigPropertyMetadata);
+const createResourceParams$t = /*#__PURE__*/ createResourceParams$D(updateDashboard_ConfigPropertyMetadata);
+function typeCheckConfig$t(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, updateDashboard_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, updateDashboard_ConfigPropertyMetadata);
     const untrustedConfig_layouts = untrustedConfig.layouts;
     if (ArrayIsArray$1(untrustedConfig_layouts)) {
         const untrustedConfig_layouts_array = [];
@@ -3479,30 +3479,30 @@ function typeCheckConfig$r(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$r(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$t(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$r(untrustedConfig);
+    const config = typeCheckConfig$t(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$r(luvio, config, options) {
-    const resourceParams = createResourceParams$r(config);
-    const request = createResourceRequest$r(resourceParams);
+function buildNetworkSnapshot$t(luvio, config, options) {
+    const resourceParams = createResourceParams$t(config);
+    const request = createResourceRequest$t(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$n(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$p(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$r(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$t(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3512,17 +3512,17 @@ function buildNetworkSnapshot$r(luvio, config, options) {
 }
 const updateDashboardAdapterFactory = (luvio) => {
     return function updateDashboard(untrustedConfig) {
-        const config = validateAdapterConfig$r(untrustedConfig, updateDashboard_ConfigPropertyNames);
+        const config = validateAdapterConfig$t(untrustedConfig, updateDashboard_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "updateDashboard"');
         }
-        return buildNetworkSnapshot$r(luvio, config);
+        return buildNetworkSnapshot$t(luvio, config);
     };
 };
 
-function validate$m(obj, path = 'AnalyticsUserRepresentation') {
-    const validateBaseAnalyticsRepresentation_validateError = validate$s(obj, path);
+function validate$p(obj, path = 'AnalyticsUserRepresentation') {
+    const validateBaseAnalyticsRepresentation_validateError = validate$v(obj, path);
     if (validateBaseAnalyticsRepresentation_validateError !== null) {
         return validateBaseAnalyticsRepresentation_validateError;
     }
@@ -3562,16 +3562,16 @@ function validate$m(obj, path = 'AnalyticsUserRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const TTL$9 = 500;
-const VERSION$h = "9a4f1166e92aab266ef84b910ef0c322";
-function validate$l(obj, path = 'FollowerAssetRepresentation') {
+const TTL$b = 500;
+const VERSION$j = "9a4f1166e92aab266ef84b910ef0c322";
+function validate$o(obj, path = 'FollowerAssetRepresentation') {
     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$m(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$p(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');
@@ -3605,68 +3605,68 @@ function validate$l(obj, path = 'FollowerAssetRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$i = 'FollowerAssetRepresentation';
-function keyBuilder$B(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$i + ':' + config.followerId;
+const RepresentationType$k = 'FollowerAssetRepresentation';
+function keyBuilder$F(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$k + ':' + config.followerId;
 }
 function keyBuilderFromType$a(luvio, object) {
     const keyParams = {
         followerId: object.followerId
     };
-    return keyBuilder$B(luvio, keyParams);
+    return keyBuilder$F(luvio, keyParams);
 }
-function normalize$h(input, existing, path, luvio, store, timestamp) {
+function normalize$j(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$E = function FollowerAssetRepresentationSelect() {
+const select$I = function FollowerAssetRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$h,
+        version: VERSION$j,
         private: [],
         opaque: true
     };
 };
-function equals$h(existing, incoming) {
+function equals$j(existing, incoming) {
     if (JSONStringify(incoming) !== JSONStringify(existing)) {
         return false;
     }
     return true;
 }
-const ingest$h = function FollowerAssetRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$j = function FollowerAssetRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$l(input);
+        const validateError = validate$o(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
     const key = keyBuilderFromType$a(luvio, input);
-    const ttlToUse = TTL$9;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$h, "UnifiedAnalytics", VERSION$h, RepresentationType$i, equals$h);
+    const ttlToUse = TTL$b;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$j, "UnifiedAnalytics", VERSION$j, RepresentationType$k, equals$j);
     return createLink(key);
 };
-function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$j(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = keyBuilderFromType$a(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$i,
+        representationName: RepresentationType$k,
         mergeable: false
     });
 }
 
-function select$D(luvio, params) {
-    return select$E();
+function select$H(luvio, params) {
+    return select$I();
 }
-function getResponseCacheKeys$q(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$h(storeKeyMap, luvio, response);
+function getResponseCacheKeys$s(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$j(storeKeyMap, luvio, response);
 }
-function ingestSuccess$m(luvio, resourceParams, response) {
+function ingestSuccess$o(luvio, resourceParams, response) {
     const { body } = response;
     const key = keyBuilderFromType$a(luvio, body);
-    luvio.storeIngest(key, ingest$h, body);
+    luvio.storeIngest(key, ingest$j, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$D(),
+        node: select$H(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3677,11 +3677,11 @@ function ingestSuccess$m(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$q(config) {
+function createResourceRequest$s(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/follow/followers/' + config.urlParams.followerId + '/follows',
+        basePath: '/tableau/follow/followers/' + config.urlParams.followerId + '/follows',
         method: 'post',
         body: config.body,
         urlParams: config.urlParams,
@@ -3691,44 +3691,44 @@ function createResourceRequest$q(config) {
     };
 }
 
-const adapterName$q = 'follow';
+const adapterName$s = 'follow';
 const follow_ConfigPropertyMetadata = [
     generateParamConfigMetadata('followerId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('assetId', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('assetType', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('followerType', true, 2 /* Body */, 0 /* String */),
 ];
-const follow_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$q, follow_ConfigPropertyMetadata);
-const createResourceParams$q = /*#__PURE__*/ createResourceParams$B(follow_ConfigPropertyMetadata);
-function typeCheckConfig$q(untrustedConfig) {
+const follow_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$s, follow_ConfigPropertyMetadata);
+const createResourceParams$s = /*#__PURE__*/ createResourceParams$D(follow_ConfigPropertyMetadata);
+function typeCheckConfig$s(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, follow_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, follow_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$q(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$s(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$q(untrustedConfig);
+    const config = typeCheckConfig$s(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$q(luvio, config, options) {
-    const resourceParams = createResourceParams$q(config);
-    const request = createResourceRequest$q(resourceParams);
+function buildNetworkSnapshot$s(luvio, config, options) {
+    const resourceParams = createResourceParams$s(config);
+    const request = createResourceRequest$s(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$m(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$o(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$q(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$s(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3738,16 +3738,16 @@ function buildNetworkSnapshot$q(luvio, config, options) {
 }
 const followAdapterFactory = (luvio) => {
     return function follow(untrustedConfig) {
-        const config = validateAdapterConfig$q(untrustedConfig, follow_ConfigPropertyNames);
+        const config = validateAdapterConfig$s(untrustedConfig, follow_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "follow"');
         }
-        return buildNetworkSnapshot$q(luvio, config);
+        return buildNetworkSnapshot$s(luvio, config);
     };
 };
 
-function validate$k(obj, path = 'FollowedAssetRepresentation') {
+function validate$n(obj, path = 'FollowedAssetRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3806,33 +3806,33 @@ function validate$k(obj, path = 'FollowedAssetRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$h = 'FollowedAssetRepresentation';
-function keyBuilder$A(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$h + ':' + config.followedAssetId;
+const RepresentationType$j = 'FollowedAssetRepresentation';
+function keyBuilder$E(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$j + ':' + config.followedAssetId;
 }
 
-function keyBuilder$z(luvio, params) {
-    return keyBuilder$A(luvio, {
+function keyBuilder$D(luvio, params) {
+    return keyBuilder$E(luvio, {
         followedAssetId: params.urlParams.followedAssetId
     });
 }
-function getResponseCacheKeys$p(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$z(luvio, resourceParams);
+function getResponseCacheKeys$r(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$D(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$h,
+        representationName: RepresentationType$j,
         mergeable: false
     });
 }
 function evictSuccess$3(luvio, resourceParams) {
-    const key = keyBuilder$z(luvio, resourceParams);
+    const key = keyBuilder$D(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$p(config) {
+function createResourceRequest$r(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/follow/followers/' + config.urlParams.followerId + '/follows/' + config.urlParams.followedAssetId + '',
+        basePath: '/tableau/follow/followers/' + config.urlParams.followerId + '/follows/' + config.urlParams.followedAssetId + '',
         method: 'delete',
         body: null,
         urlParams: config.urlParams,
@@ -3842,34 +3842,34 @@ function createResourceRequest$p(config) {
     };
 }
 
-const adapterName$p = 'unfollow';
+const adapterName$r = 'unfollow';
 const unfollow_ConfigPropertyMetadata = [
     generateParamConfigMetadata('followedAssetId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('followerId', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const unfollow_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$p, unfollow_ConfigPropertyMetadata);
-const createResourceParams$p = /*#__PURE__*/ createResourceParams$B(unfollow_ConfigPropertyMetadata);
-function typeCheckConfig$p(untrustedConfig) {
+const unfollow_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$r, unfollow_ConfigPropertyMetadata);
+const createResourceParams$r = /*#__PURE__*/ createResourceParams$D(unfollow_ConfigPropertyMetadata);
+function typeCheckConfig$r(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, unfollow_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, unfollow_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$p(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$r(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$p(untrustedConfig);
+    const config = typeCheckConfig$r(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$p(luvio, config, options) {
-    const resourceParams = createResourceParams$p(config);
-    const request = createResourceRequest$p(resourceParams);
+function buildNetworkSnapshot$r(luvio, config, options) {
+    const resourceParams = createResourceParams$r(config);
+    const request = createResourceRequest$r(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -3877,7 +3877,7 @@ function buildNetworkSnapshot$p(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$p(cache, luvio, resourceParams);
+            getResponseCacheKeys$r(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -3887,18 +3887,18 @@ function buildNetworkSnapshot$p(luvio, config, options) {
 }
 const unfollowAdapterFactory = (luvio) => {
     return function UnifiedAnalyticsunfollow(untrustedConfig) {
-        const config = validateAdapterConfig$p(untrustedConfig, unfollow_ConfigPropertyNames);
+        const config = validateAdapterConfig$r(untrustedConfig, unfollow_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$p}"`);
+            throw new Error(`Invalid config for "${adapterName$r}"`);
         }
-        return buildNetworkSnapshot$p(luvio, config);
+        return buildNetworkSnapshot$r(luvio, config);
     };
 };
 
-const TTL$8 = 500;
-const VERSION$g = "1fd0770995d332e49822d6bbabe35e87";
-function validate$j(obj, path = 'FollowerCollectionRepresentation') {
+const TTL$a = 500;
+const VERSION$i = "1fd0770995d332e49822d6bbabe35e87";
+function validate$m(obj, path = 'FollowerCollectionRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3911,7 +3911,7 @@ function validate$j(obj, path = 'FollowerCollectionRepresentation') {
         for (let i = 0; i < obj_followers.length; i++) {
             const obj_followers_item = obj_followers[i];
             const path_followers_item = path_followers + '[' + i + ']';
-            const referencepath_followers_itemValidationError = validate$m(obj_followers_item, path_followers_item);
+            const referencepath_followers_itemValidationError = validate$p(obj_followers_item, path_followers_item);
             if (referencepath_followers_itemValidationError !== null) {
                 let message = 'Object doesn\'t match AnalyticsUserRepresentation (at "' + path_followers_item + '")\n';
                 message += referencepath_followers_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -3921,11 +3921,414 @@ function validate$j(obj, path = 'FollowerCollectionRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$g = 'FollowerCollectionRepresentation';
+const RepresentationType$i = 'FollowerCollectionRepresentation';
+function normalize$i(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$G = function FollowerCollectionRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$i,
+        private: [],
+        opaque: true
+    };
+};
+function equals$i(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$i = function FollowerCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$m(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL$a;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$i, "UnifiedAnalytics", VERSION$i, RepresentationType$i, equals$i);
+    return createLink(key);
+};
+function getTypeCacheKeys$i(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$i,
+        mergeable: false
+    });
+}
+
+function select$F(luvio, params) {
+    return select$G();
+}
+function keyBuilder$C(luvio, params) {
+    return keyPrefix + '::FollowerCollectionRepresentation:(' + 'followerId:' + params.queryParams.followerId + ',' + 'followerType:' + params.queryParams.followerType + ',' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ',' + 'followedAssetId:' + params.urlParams.followedAssetId + ')';
+}
+function getResponseCacheKeys$q(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$i(storeKeyMap, luvio, response, () => keyBuilder$C(luvio, resourceParams));
+}
+function ingestSuccess$n(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$C(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$i, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$F(),
+        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$c(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$C(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$a,
+        namespace: keyPrefix,
+        version: VERSION$i,
+        representationName: RepresentationType$i
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$q(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v62.0',
+        basePath: '/tableau/follow/assets/' + config.urlParams.followedAssetId + '/followers',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$q = 'getFollowers';
+const getFollowers_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('followedAssetId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('followerId', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('followerType', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('limit', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
+];
+const getFollowers_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$q, getFollowers_ConfigPropertyMetadata);
+const createResourceParams$q = /*#__PURE__*/ createResourceParams$D(getFollowers_ConfigPropertyMetadata);
+function keyBuilder$B(luvio, config) {
+    const resourceParams = createResourceParams$q(config);
+    return keyBuilder$C(luvio, resourceParams);
+}
+function typeCheckConfig$q(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$D(untrustedConfig, config, getFollowers_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$q(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$q(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$c(luvio, config) {
+    createResourceParams$q(config);
+    return select$F();
+}
+function onFetchResponseSuccess$c(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$n(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$q(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$c(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$c(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$q(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$q(luvio, config, options) {
+    const resourceParams = createResourceParams$q(config);
+    const request = createResourceRequest$q(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$c(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$q(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$c(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$c(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$q, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$B(luvio, config),
+        node: adapterFragment$c(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$q(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getFollowersAdapterFactory = (luvio) => function UnifiedAnalytics__getFollowers(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$q(untrustedConfig, getFollowers_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$c, buildNetworkSnapshotCachePolicy$c);
+};
+
+const TTL$9 = 500;
+const VERSION$h = "1f44696f5314fa2f963688e14067a00c";
+function validate$l(obj, path = 'FollowedAssetCollectionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_followedAssets = obj.followedAssets;
+        const path_followedAssets = path + '.followedAssets';
+        if (!ArrayIsArray(obj_followedAssets)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_followedAssets + '" (at "' + path_followedAssets + '")');
+        }
+        for (let i = 0; i < obj_followedAssets.length; i++) {
+            const obj_followedAssets_item = obj_followedAssets[i];
+            const path_followedAssets_item = path_followedAssets + '[' + i + ']';
+            const referencepath_followedAssets_itemValidationError = validate$n(obj_followedAssets_item, path_followedAssets_item);
+            if (referencepath_followedAssets_itemValidationError !== null) {
+                let message = 'Object doesn\'t match FollowedAssetRepresentation (at "' + path_followedAssets_item + '")\n';
+                message += referencepath_followedAssets_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$h = 'FollowedAssetCollectionRepresentation';
+function normalize$h(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$E = function FollowedAssetCollectionRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$h,
+        private: [],
+        opaque: true
+    };
+};
+function equals$h(existing, incoming) {
+    if (JSONStringify(incoming) !== JSONStringify(existing)) {
+        return false;
+    }
+    return true;
+}
+const ingest$h = function FollowedAssetCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$l(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const ttlToUse = TTL$9;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$h, "UnifiedAnalytics", VERSION$h, RepresentationType$h, equals$h);
+    return createLink(key);
+};
+function getTypeCacheKeys$h(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$h,
+        mergeable: false
+    });
+}
+
+function select$D(luvio, params) {
+    return select$E();
+}
+function keyBuilder$A(luvio, params) {
+    return keyPrefix + '::FollowedAssetCollectionRepresentation:(' + 'followedAssetType:' + params.queryParams.followedAssetType + ',' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ',' + 'followerId:' + params.urlParams.followerId + ')';
+}
+function getResponseCacheKeys$p(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$h(storeKeyMap, luvio, response, () => keyBuilder$A(luvio, resourceParams));
+}
+function ingestSuccess$m(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$A(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$h, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$D(),
+        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$b(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$A(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$9,
+        namespace: keyPrefix,
+        version: VERSION$h,
+        representationName: RepresentationType$h
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
+function createResourceRequest$p(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v62.0',
+        basePath: '/tableau/follow/followers/' + config.urlParams.followerId + '/followed-assets',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$p = 'getFollowedAssets';
+const getFollowedAssets_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('followerId', true, 0 /* UrlParameter */, 0 /* String */),
+    generateParamConfigMetadata('followedAssetType', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('limit', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
+];
+const getFollowedAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$p, getFollowedAssets_ConfigPropertyMetadata);
+const createResourceParams$p = /*#__PURE__*/ createResourceParams$D(getFollowedAssets_ConfigPropertyMetadata);
+function keyBuilder$z(luvio, config) {
+    const resourceParams = createResourceParams$p(config);
+    return keyBuilder$A(luvio, resourceParams);
+}
+function typeCheckConfig$p(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$D(untrustedConfig, config, getFollowedAssets_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$p(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$p(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$b(luvio, config) {
+    createResourceParams$p(config);
+    return select$D();
+}
+function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$m(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$p(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$b(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$b(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$p(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$p(luvio, config, options) {
+    const resourceParams = createResourceParams$p(config);
+    const request = createResourceRequest$p(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$b(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$p(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$b(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$p, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$z(luvio, config),
+        node: adapterFragment$b(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$p(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getFollowedAssetsAdapterFactory = (luvio) => function UnifiedAnalytics__getFollowedAssets(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$p(untrustedConfig, getFollowedAssets_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$b, buildNetworkSnapshotCachePolicy$b);
+};
+
+const TTL$8 = 500;
+const VERSION$g = "a4167cdb0a6477d9d7ddbe70da03f1b4";
+function validate$k(obj, path = 'UniqueFollowerCountRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_uniqueFollowerCount = obj.uniqueFollowerCount;
+        const path_uniqueFollowerCount = path + '.uniqueFollowerCount';
+        if (typeof obj_uniqueFollowerCount !== 'number' || (typeof obj_uniqueFollowerCount === 'number' && Math.floor(obj_uniqueFollowerCount) !== obj_uniqueFollowerCount)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_uniqueFollowerCount + '" (at "' + path_uniqueFollowerCount + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$g = 'UniqueFollowerCountRepresentation';
 function normalize$g(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$C = function FollowerCollectionRepresentationSelect() {
+const select$C = function UniqueFollowerCountRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$g,
@@ -3939,9 +4342,9 @@ function equals$g(existing, incoming) {
     }
     return true;
 }
-const ingest$g = function FollowerCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$g = function UniqueFollowerCountRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$j(input);
+        const validateError = validate$k(input);
         if (validateError !== null) {
             throw validateError;
         }
@@ -3965,7 +4368,7 @@ function select$B(luvio, params) {
     return select$C();
 }
 function keyBuilder$y(luvio, params) {
-    return keyPrefix + '::FollowerCollectionRepresentation:(' + 'followerId:' + params.queryParams.followerId + ',' + 'followerType:' + params.queryParams.followerType + ',' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ',' + 'followedAssetId:' + params.urlParams.followedAssetId + ')';
+    return keyPrefix + '::UniqueFollowerCountRepresentation:(' + 'followedAssetType:' + params.queryParams.followedAssetType + ',' + 'followedAssetId:' + params.urlParams.followedAssetId + ')';
 }
 function getResponseCacheKeys$o(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys$g(storeKeyMap, luvio, response, () => keyBuilder$y(luvio, resourceParams));
@@ -4003,7 +4406,7 @@ function createResourceRequest$o(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/follow/assets/' + config.urlParams.followedAssetId + '/followers',
+        basePath: '/tableau/follow/assets/' + config.urlParams.followedAssetId + '/follower-count',
         method: 'get',
         body: null,
         urlParams: config.urlParams,
@@ -4013,23 +4416,20 @@ function createResourceRequest$o(config) {
     };
 }
 
-const adapterName$o = 'getFollowers';
-const getFollowers_ConfigPropertyMetadata = [
+const adapterName$o = 'getUniqueFollowerCount';
+const getUniqueFollowerCount_ConfigPropertyMetadata = [
     generateParamConfigMetadata('followedAssetId', true, 0 /* UrlParameter */, 0 /* String */),
-    generateParamConfigMetadata('followerId', false, 1 /* QueryParameter */, 0 /* String */),
-    generateParamConfigMetadata('followerType', false, 1 /* QueryParameter */, 0 /* String */),
-    generateParamConfigMetadata('limit', false, 1 /* QueryParameter */, 3 /* Integer */),
-    generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
+    generateParamConfigMetadata('followedAssetType', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getFollowers_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, getFollowers_ConfigPropertyMetadata);
-const createResourceParams$o = /*#__PURE__*/ createResourceParams$B(getFollowers_ConfigPropertyMetadata);
+const getUniqueFollowerCount_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$o, getUniqueFollowerCount_ConfigPropertyMetadata);
+const createResourceParams$o = /*#__PURE__*/ createResourceParams$D(getUniqueFollowerCount_ConfigPropertyMetadata);
 function keyBuilder$x(luvio, config) {
     const resourceParams = createResourceParams$o(config);
     return keyBuilder$y(luvio, resourceParams);
 }
 function typeCheckConfig$o(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getFollowers_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getUniqueFollowerCount_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$o(untrustedConfig, configPropertyNames) {
@@ -4078,7 +4478,7 @@ function buildNetworkSnapshot$o(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$o, undefined, false);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$o, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
@@ -4093,8 +4493,8 @@ function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     });
     return cacheSnapshot;
 }
-const getFollowersAdapterFactory = (luvio) => function UnifiedAnalytics__getFollowers(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$o(untrustedConfig, getFollowers_ConfigPropertyNames);
+const getUniqueFollowerCountAdapterFactory = (luvio) => function UnifiedAnalytics__getUniqueFollowerCount(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$o(untrustedConfig, getUniqueFollowerCount_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -4103,36 +4503,45 @@ const getFollowersAdapterFactory = (luvio) => function UnifiedAnalytics__getFoll
     buildCachedSnapshotCachePolicy$a, buildNetworkSnapshotCachePolicy$a);
 };
 
-const TTL$7 = 500;
-const VERSION$f = "1f44696f5314fa2f963688e14067a00c";
-function validate$i(obj, path = 'FollowedAssetCollectionRepresentation') {
+const TTL$7 = 1000;
+const VERSION$f = "f2e0254a8e6b03f2289f318634389df3";
+function validate$j(obj, path = 'UnifiedAnalyticsLogLinesRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        const obj_followedAssets = obj.followedAssets;
-        const path_followedAssets = path + '.followedAssets';
-        if (!ArrayIsArray(obj_followedAssets)) {
-            return new TypeError('Expected "array" but received "' + typeof obj_followedAssets + '" (at "' + path_followedAssets + '")');
+        const obj_failureCount = obj.failureCount;
+        const path_failureCount = path + '.failureCount';
+        if (typeof obj_failureCount !== 'number' || (typeof obj_failureCount === 'number' && Math.floor(obj_failureCount) !== obj_failureCount)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_failureCount + '" (at "' + path_failureCount + '")');
         }
-        for (let i = 0; i < obj_followedAssets.length; i++) {
-            const obj_followedAssets_item = obj_followedAssets[i];
-            const path_followedAssets_item = path_followedAssets + '[' + i + ']';
-            const referencepath_followedAssets_itemValidationError = validate$k(obj_followedAssets_item, path_followedAssets_item);
-            if (referencepath_followedAssets_itemValidationError !== null) {
-                let message = 'Object doesn\'t match FollowedAssetRepresentation (at "' + path_followedAssets_item + '")\n';
-                message += referencepath_followedAssets_itemValidationError.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_successCount = obj.successCount;
+        const path_successCount = path + '.successCount';
+        if (typeof obj_successCount !== 'number' || (typeof obj_successCount === 'number' && Math.floor(obj_successCount) !== obj_successCount)) {
+            return new TypeError('Expected "integer" but received "' + typeof obj_successCount + '" (at "' + path_successCount + '")');
         }
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$f = 'FollowedAssetCollectionRepresentation';
+const RepresentationType$f = 'UnifiedAnalyticsLogLinesRepresentation';
+function keyBuilder$w(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$f + ':' + config.id;
+}
+function keyBuilderFromType$9(luvio, object) {
+    const keyParams = {
+        id: object.id
+    };
+    return keyBuilder$w(luvio, keyParams);
+}
 function normalize$f(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$A = function FollowedAssetCollectionRepresentationSelect() {
+const select$A = function UnifiedAnalyticsLogLinesRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$f,
@@ -4146,21 +4555,21 @@ function equals$f(existing, incoming) {
     }
     return true;
 }
-const ingest$f = function FollowedAssetCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$f = function UnifiedAnalyticsLogLinesRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$i(input);
+        const validateError = validate$j(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = path.fullPath;
+    const key = keyBuilderFromType$9(luvio, input);
     const ttlToUse = TTL$7;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$f, "UnifiedAnalytics", VERSION$f, RepresentationType$f, equals$f);
     return createLink(key);
 };
 function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = fullPathFactory();
+    const rootKey = keyBuilderFromType$9(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$f,
@@ -4171,21 +4580,18 @@ function getTypeCacheKeys$f(rootKeySet, luvio, input, fullPathFactory) {
 function select$z(luvio, params) {
     return select$A();
 }
-function keyBuilder$w(luvio, params) {
-    return keyPrefix + '::FollowedAssetCollectionRepresentation:(' + 'followedAssetType:' + params.queryParams.followedAssetType + ',' + 'limit:' + params.queryParams.limit + ',' + 'offset:' + params.queryParams.offset + ',' + 'followerId:' + params.urlParams.followerId + ')';
-}
 function getResponseCacheKeys$n(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$f(storeKeyMap, luvio, response, () => keyBuilder$w(luvio, resourceParams));
+    getTypeCacheKeys$f(storeKeyMap, luvio, response);
 }
-function ingestSuccess$k(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$k(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilder$w(luvio, resourceParams);
+    const key = keyBuilderFromType$9(luvio, body);
     luvio.storeIngest(key, ingest$f, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$z(),
         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');
@@ -4194,48 +4600,37 @@ function ingestSuccess$k(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$9(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$w(luvio, params);
-    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
-    const storeMetadataParams = {
-        ttl: TTL$7,
-        namespace: keyPrefix,
-        version: VERSION$f,
-        representationName: RepresentationType$f
-    };
-    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
-    return errorSnapshot;
-}
 function createResourceRequest$n(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/follow/followers/' + config.urlParams.followerId + '/followed-assets',
-        method: 'get',
-        body: null,
-        urlParams: config.urlParams,
-        queryParams: config.queryParams,
+        basePath: '/tableau/loglines',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
         headers,
         priority: 'normal',
     };
 }
 
-const adapterName$n = 'getFollowedAssets';
-const getFollowedAssets_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('followerId', true, 0 /* UrlParameter */, 0 /* String */),
-    generateParamConfigMetadata('followedAssetType', false, 1 /* QueryParameter */, 0 /* String */),
-    generateParamConfigMetadata('limit', false, 1 /* QueryParameter */, 3 /* Integer */),
-    generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
+const adapterName$n = 'createLoglines';
+const createLoglines_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('loglines', true, 2 /* Body */, 4 /* Unsupported */, true),
 ];
-const getFollowedAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, getFollowedAssets_ConfigPropertyMetadata);
-const createResourceParams$n = /*#__PURE__*/ createResourceParams$B(getFollowedAssets_ConfigPropertyMetadata);
-function keyBuilder$v(luvio, config) {
-    const resourceParams = createResourceParams$n(config);
-    return keyBuilder$w(luvio, resourceParams);
-}
+const createLoglines_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$n, createLoglines_ConfigPropertyMetadata);
+const createResourceParams$n = /*#__PURE__*/ createResourceParams$D(createLoglines_ConfigPropertyMetadata);
 function typeCheckConfig$n(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getFollowedAssets_ConfigPropertyMetadata);
+    const untrustedConfig_loglines = untrustedConfig.loglines;
+    if (ArrayIsArray$1(untrustedConfig_loglines)) {
+        const untrustedConfig_loglines_array = [];
+        for (let i = 0, arrayLength = untrustedConfig_loglines.length; i < arrayLength; i++) {
+            const untrustedConfig_loglines_item = untrustedConfig_loglines[i];
+            untrustedConfig_loglines_array.push(untrustedConfig_loglines_item);
+        }
+        config.loglines = untrustedConfig_loglines_array;
+    }
     return config;
 }
 function validateAdapterConfig$n(untrustedConfig, configPropertyNames) {
@@ -4251,103 +4646,102 @@ function validateAdapterConfig$n(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function adapterFragment$9(luvio, config) {
-    createResourceParams$n(config);
-    return select$z();
-}
-function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$k(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function onFetchResponseError$9(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$9(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
 function buildNetworkSnapshot$n(luvio, config, options) {
     const resourceParams = createResourceParams$n(config);
     const request = createResourceRequest$n(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$k(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
             const cache = new StoreKeyMap();
             getResponseCacheKeys$n(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$9(luvio, config, resourceParams, response));
+        deepFreeze(response);
+        throw response;
     });
 }
-function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$n, undefined, false);
-}
-function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
-    const { luvio, config } = context;
-    const selector = {
-        recordId: keyBuilder$v(luvio, config),
-        node: adapterFragment$9(luvio, config),
-        variables: {},
+const createLoglinesAdapterFactory = (luvio) => {
+    return function createLoglines(untrustedConfig) {
+        const config = validateAdapterConfig$n(untrustedConfig, createLoglines_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createLoglines"');
+        }
+        return buildNetworkSnapshot$n(luvio, config);
     };
-    const cacheSnapshot = storeLookup(selector, {
-        config,
-        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
-    });
-    return cacheSnapshot;
-}
-const getFollowedAssetsAdapterFactory = (luvio) => function UnifiedAnalytics__getFollowedAssets(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$n(untrustedConfig, getFollowedAssets_ConfigPropertyNames);
-    // Invalid or incomplete config
-    if (config === null) {
-        return null;
-    }
-    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
 };
 
-const TTL$6 = 1000;
-const VERSION$e = "f2e0254a8e6b03f2289f318634389df3";
-function validate$h(obj, path = 'UnifiedAnalyticsLogLinesRepresentation') {
+function validate$i(obj, path = 'OrgRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
         }
-        const obj_failureCount = obj.failureCount;
-        const path_failureCount = path + '.failureCount';
-        if (typeof obj_failureCount !== 'number' || (typeof obj_failureCount === 'number' && Math.floor(obj_failureCount) !== obj_failureCount)) {
-            return new TypeError('Expected "integer" but received "' + typeof obj_failureCount + '" (at "' + path_failureCount + '")');
-        }
         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_successCount = obj.successCount;
-        const path_successCount = path + '.successCount';
-        if (typeof obj_successCount !== 'number' || (typeof obj_successCount === 'number' && Math.floor(obj_successCount) !== obj_successCount)) {
-            return new TypeError('Expected "integer" but received "' + typeof obj_successCount + '" (at "' + path_successCount + '")');
+        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_orgUrl = obj.orgUrl;
+        const path_orgUrl = path + '.orgUrl';
+        if (typeof obj_orgUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_orgUrl + '" (at "' + path_orgUrl + '")');
+        }
+        const obj_targetUrl = obj.targetUrl;
+        const path_targetUrl = path + '.targetUrl';
+        if (typeof obj_targetUrl !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_targetUrl + '" (at "' + path_targetUrl + '")');
         }
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$e = 'UnifiedAnalyticsLogLinesRepresentation';
-function keyBuilder$u(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$e + ':' + config.id;
-}
-function keyBuilderFromType$9(luvio, object) {
-    const keyParams = {
-        id: object.id
-    };
-    return keyBuilder$u(luvio, keyParams);
+
+const TTL$6 = 500;
+const VERSION$e = "ebd45d9f8ecdc711027eec047d0803ac";
+function validate$h(obj, path = 'OrgCollectionRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_currentOrg = obj.currentOrg;
+        const path_currentOrg = path + '.currentOrg';
+        const referencepath_currentOrgValidationError = validate$i(obj_currentOrg, path_currentOrg);
+        if (referencepath_currentOrgValidationError !== null) {
+            let message = 'Object doesn\'t match OrgRepresentation (at "' + path_currentOrg + '")\n';
+            message += referencepath_currentOrgValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
+        const obj_orgs = obj.orgs;
+        const path_orgs = path + '.orgs';
+        if (!ArrayIsArray(obj_orgs)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_orgs + '" (at "' + path_orgs + '")');
+        }
+        for (let i = 0; i < obj_orgs.length; i++) {
+            const obj_orgs_item = obj_orgs[i];
+            const path_orgs_item = path_orgs + '[' + i + ']';
+            const referencepath_orgs_itemValidationError = validate$i(obj_orgs_item, path_orgs_item);
+            if (referencepath_orgs_itemValidationError !== null) {
+                let message = 'Object doesn\'t match OrgRepresentation (at "' + path_orgs_item + '")\n';
+                message += referencepath_orgs_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
 }
+const RepresentationType$e = 'OrgCollectionRepresentation';
 function normalize$e(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$y = function UnifiedAnalyticsLogLinesRepresentationSelect() {
+const select$y = function OrgCollectionRepresentationSelect() {
     return {
         kind: 'Fragment',
         version: VERSION$e,
@@ -4361,21 +4755,21 @@ function equals$e(existing, incoming) {
     }
     return true;
 }
-const ingest$e = function UnifiedAnalyticsLogLinesRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$e = function OrgCollectionRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$h(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$9(luvio, input);
+    const key = path.fullPath;
     const ttlToUse = TTL$6;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$e, "UnifiedAnalytics", VERSION$e, RepresentationType$e, equals$e);
     return createLink(key);
 };
 function getTypeCacheKeys$e(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$9(luvio, input);
+    const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$e,
@@ -4386,18 +4780,21 @@ function getTypeCacheKeys$e(rootKeySet, luvio, input, fullPathFactory) {
 function select$x(luvio, params) {
     return select$y();
 }
+function keyBuilder$v(luvio, params) {
+    return keyPrefix + '::OrgCollectionRepresentation:(' + 'userName:' + params.urlParams.userName + ')';
+}
 function getResponseCacheKeys$m(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$e(storeKeyMap, luvio, response);
+    getTypeCacheKeys$e(storeKeyMap, luvio, response, () => keyBuilder$v(luvio, resourceParams));
 }
-function ingestSuccess$j(luvio, resourceParams, response) {
+function ingestSuccess$j(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilderFromType$9(luvio, body);
+    const key = keyBuilder$v(luvio, resourceParams);
     luvio.storeIngest(key, ingest$e, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$x(),
         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');
@@ -4406,37 +4803,45 @@ function ingestSuccess$j(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
+function ingestError$9(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$v(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    const storeMetadataParams = {
+        ttl: TTL$6,
+        namespace: keyPrefix,
+        version: VERSION$e,
+        representationName: RepresentationType$e
+    };
+    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
+    return errorSnapshot;
+}
 function createResourceRequest$m(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/loglines',
-        method: 'post',
-        body: config.body,
-        urlParams: {},
+        basePath: '/tableau/orgs/' + config.urlParams.userName + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
         queryParams: {},
         headers,
         priority: 'normal',
     };
 }
 
-const adapterName$m = 'createLoglines';
-const createLoglines_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('loglines', true, 2 /* Body */, 4 /* Unsupported */, true),
+const adapterName$m = 'getOrg';
+const getOrg_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('userName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
-const createLoglines_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, createLoglines_ConfigPropertyMetadata);
-const createResourceParams$m = /*#__PURE__*/ createResourceParams$B(createLoglines_ConfigPropertyMetadata);
+const getOrg_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$m, getOrg_ConfigPropertyMetadata);
+const createResourceParams$m = /*#__PURE__*/ createResourceParams$D(getOrg_ConfigPropertyMetadata);
+function keyBuilder$u(luvio, config) {
+    const resourceParams = createResourceParams$m(config);
+    return keyBuilder$v(luvio, resourceParams);
+}
 function typeCheckConfig$m(untrustedConfig) {
     const config = {};
-    const untrustedConfig_loglines = untrustedConfig.loglines;
-    if (ArrayIsArray$1(untrustedConfig_loglines)) {
-        const untrustedConfig_loglines_array = [];
-        for (let i = 0, arrayLength = untrustedConfig_loglines.length; i < arrayLength; i++) {
-            const untrustedConfig_loglines_item = untrustedConfig_loglines[i];
-            untrustedConfig_loglines_array.push(untrustedConfig_loglines_item);
-        }
-        config.loglines = untrustedConfig_loglines_array;
-    }
+    typeCheckConfig$D(untrustedConfig, config, getOrg_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$m(untrustedConfig, configPropertyNames) {
@@ -4452,33 +4857,62 @@ function validateAdapterConfig$m(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
+function adapterFragment$9(luvio, config) {
+    createResourceParams$m(config);
+    return select$x();
+}
+function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$j(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$9(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$9(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
 function buildNetworkSnapshot$m(luvio, config, options) {
     const resourceParams = createResourceParams$m(config);
     const request = createResourceRequest$m(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$j(luvio, resourceParams, response);
-            return luvio.storeBroadcast().then(() => snapshot);
-        }, () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
             getResponseCacheKeys$m(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        deepFreeze(response);
-        throw response;
+        return luvio.handleErrorResponse(() => onFetchResponseError$9(luvio, config, resourceParams, response));
     });
 }
-const createLoglinesAdapterFactory = (luvio) => {
-    return function createLoglines(untrustedConfig) {
-        const config = validateAdapterConfig$m(untrustedConfig, createLoglines_ConfigPropertyNames);
-        // Invalid or incomplete config
-        if (config === null) {
-            throw new Error('Invalid config for "createLoglines"');
-        }
-        return buildNetworkSnapshot$m(luvio, config);
+function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$m, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$u(luvio, config),
+        node: adapterFragment$9(luvio, config),
+        variables: {},
     };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getOrgAdapterFactory = (luvio) => function UnifiedAnalytics__getOrg(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$m(untrustedConfig, getOrg_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
 };
 
 const TTL$5 = 1000;
@@ -4746,7 +5180,7 @@ function createResourceRequest$l(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/slack/channels',
+        basePath: '/tableau/slack/channels',
         method: 'get',
         body: null,
         urlParams: {},
@@ -4761,14 +5195,14 @@ const getAssetSlackChannels_ConfigPropertyMetadata = [
     generateParamConfigMetadata('assetId', true, 1 /* QueryParameter */, 0 /* String */),
 ];
 const getAssetSlackChannels_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$l, getAssetSlackChannels_ConfigPropertyMetadata);
-const createResourceParams$l = /*#__PURE__*/ createResourceParams$B(getAssetSlackChannels_ConfigPropertyMetadata);
+const createResourceParams$l = /*#__PURE__*/ createResourceParams$D(getAssetSlackChannels_ConfigPropertyMetadata);
 function keyBuilder$r(luvio, config) {
     const resourceParams = createResourceParams$l(config);
     return keyBuilder$s(luvio, resourceParams);
 }
 function typeCheckConfig$l(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getAssetSlackChannels_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getAssetSlackChannels_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$l(untrustedConfig, configPropertyNames) {
@@ -4817,7 +5251,7 @@ function buildNetworkSnapshot$l(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$l, undefined, false);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$l, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
@@ -4869,7 +5303,7 @@ function createResourceRequest$k(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/slack/channels',
+        basePath: '/tableau/slack/channels',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -4886,10 +5320,10 @@ const createAssetSlackChannel_ConfigPropertyMetadata = [
     generateParamConfigMetadata('teamId', true, 2 /* Body */, 0 /* String */),
 ];
 const createAssetSlackChannel_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$k, createAssetSlackChannel_ConfigPropertyMetadata);
-const createResourceParams$k = /*#__PURE__*/ createResourceParams$B(createAssetSlackChannel_ConfigPropertyMetadata);
+const createResourceParams$k = /*#__PURE__*/ createResourceParams$D(createAssetSlackChannel_ConfigPropertyMetadata);
 function typeCheckConfig$k(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, createAssetSlackChannel_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, createAssetSlackChannel_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$k(untrustedConfig, configPropertyNames) {
@@ -4949,7 +5383,7 @@ function validate$e(obj, path = 'AnalyticsUsersQueryResultsRepresentation') {
         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$m(obj_items_item, path_items_item);
+            const referencepath_items_itemValidationError = validate$p(obj_items_item, path_items_item);
             if (referencepath_items_itemValidationError !== null) {
                 let message = 'Object doesn\'t match AnalyticsUserRepresentation (at "' + path_items_item + '")\n';
                 message += referencepath_items_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5050,7 +5484,7 @@ function createResourceRequest$j(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/users/query',
+        basePath: '/tableau/users/query',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -5066,10 +5500,10 @@ const queryUsers_ConfigPropertyMetadata = [
     generateParamConfigMetadata('useAutoSuggest', true, 2 /* Body */, 1 /* Boolean */),
 ];
 const queryUsers_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$j, queryUsers_ConfigPropertyMetadata);
-const createResourceParams$j = /*#__PURE__*/ createResourceParams$B(queryUsers_ConfigPropertyMetadata);
+const createResourceParams$j = /*#__PURE__*/ createResourceParams$D(queryUsers_ConfigPropertyMetadata);
 function typeCheckConfig$j(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, queryUsers_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, queryUsers_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$j(untrustedConfig, configPropertyNames) {
@@ -5122,7 +5556,7 @@ function validate$d(obj, path = 'VisualizationRepresentation') {
         }
         const obj_createdBy = obj.createdBy;
         const path_createdBy = path + '.createdBy';
-        const referencepath_createdByValidationError = validate$m(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$p(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');
@@ -5197,7 +5631,7 @@ function validate$d(obj, path = 'VisualizationRepresentation') {
         if (obj.lastModifiedBy !== undefined) {
             const obj_lastModifiedBy = obj.lastModifiedBy;
             const path_lastModifiedBy = path + '.lastModifiedBy';
-            const referencepath_lastModifiedByValidationError = validate$m(obj_lastModifiedBy, path_lastModifiedBy);
+            const referencepath_lastModifiedByValidationError = validate$p(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');
@@ -5443,7 +5877,7 @@ function createResourceRequest$i(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/visualizations',
+        basePath: '/tableau/visualizations',
         method: 'get',
         body: null,
         urlParams: {},
@@ -5459,14 +5893,14 @@ const getVisualizations_ConfigPropertyMetadata = [
     generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
 ];
 const getVisualizations_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$i, getVisualizations_ConfigPropertyMetadata);
-const createResourceParams$i = /*#__PURE__*/ createResourceParams$B(getVisualizations_ConfigPropertyMetadata);
+const createResourceParams$i = /*#__PURE__*/ createResourceParams$D(getVisualizations_ConfigPropertyMetadata);
 function keyBuilder$n(luvio, config) {
     const resourceParams = createResourceParams$i(config);
     return keyBuilder$o(luvio, resourceParams);
 }
 function typeCheckConfig$i(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getVisualizations_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getVisualizations_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$i(untrustedConfig, configPropertyNames) {
@@ -5515,7 +5949,7 @@ function buildNetworkSnapshot$i(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$i, undefined, false);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$i, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -5567,7 +6001,7 @@ function createResourceRequest$h(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/visualizations',
+        basePath: '/tableau/visualizations',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -5591,10 +6025,10 @@ const createVisualization_ConfigPropertyMetadata = [
     generateParamConfigMetadata('interactions', false, 2 /* Body */, 4 /* Unsupported */, true),
 ];
 const createVisualization_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$h, createVisualization_ConfigPropertyMetadata);
-const createResourceParams$h = /*#__PURE__*/ createResourceParams$B(createVisualization_ConfigPropertyMetadata);
+const createResourceParams$h = /*#__PURE__*/ createResourceParams$D(createVisualization_ConfigPropertyMetadata);
 function typeCheckConfig$h(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, createVisualization_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, createVisualization_ConfigPropertyMetadata);
     const untrustedConfig_dataSource = untrustedConfig.dataSource;
     if (untrustedIsObject(untrustedConfig_dataSource)) {
         const untrustedConfig_dataSource_object = {};
@@ -5744,7 +6178,7 @@ function createResourceRequest$g(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/visualizations/' + config.urlParams.visualizationIdOrApiName + '',
+        basePath: '/tableau/visualizations/' + config.urlParams.visualizationIdOrApiName + '',
         method: 'delete',
         body: null,
         urlParams: config.urlParams,
@@ -5759,10 +6193,10 @@ const deleteVisualization_ConfigPropertyMetadata = [
     generateParamConfigMetadata('visualizationIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteVisualization_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$g, deleteVisualization_ConfigPropertyMetadata);
-const createResourceParams$g = /*#__PURE__*/ createResourceParams$B(deleteVisualization_ConfigPropertyMetadata);
+const createResourceParams$g = /*#__PURE__*/ createResourceParams$D(deleteVisualization_ConfigPropertyMetadata);
 function typeCheckConfig$g(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, deleteVisualization_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, deleteVisualization_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$g(untrustedConfig, configPropertyNames) {
@@ -5845,7 +6279,7 @@ function createResourceRequest$f(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/visualizations/' + config.urlParams.visualizationIdOrApiName + '',
+        basePath: '/tableau/visualizations/' + config.urlParams.visualizationIdOrApiName + '',
         method: 'get',
         body: null,
         urlParams: config.urlParams,
@@ -5860,14 +6294,14 @@ const getVisualization_ConfigPropertyMetadata = [
     generateParamConfigMetadata('visualizationIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getVisualization_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, getVisualization_ConfigPropertyMetadata);
-const createResourceParams$f = /*#__PURE__*/ createResourceParams$B(getVisualization_ConfigPropertyMetadata);
+const createResourceParams$f = /*#__PURE__*/ createResourceParams$D(getVisualization_ConfigPropertyMetadata);
 function keyBuilder$k(luvio, config) {
     const resourceParams = createResourceParams$f(config);
     return keyBuilder$l(luvio, resourceParams);
 }
 function typeCheckConfig$f(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getVisualization_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getVisualization_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
@@ -5916,7 +6350,7 @@ function buildNetworkSnapshot$f(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$f, undefined, false);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$f, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -5968,7 +6402,7 @@ function createResourceRequest$e(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/visualizations/' + config.urlParams.visualizationIdOrApiName + '',
+        basePath: '/tableau/visualizations/' + config.urlParams.visualizationIdOrApiName + '',
         method: 'patch',
         body: config.body,
         urlParams: config.urlParams,
@@ -5993,10 +6427,10 @@ const updateVisualization_ConfigPropertyMetadata = [
     generateParamConfigMetadata('interactions', false, 2 /* Body */, 4 /* Unsupported */, true),
 ];
 const updateVisualization_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, updateVisualization_ConfigPropertyMetadata);
-const createResourceParams$e = /*#__PURE__*/ createResourceParams$B(updateVisualization_ConfigPropertyMetadata);
+const createResourceParams$e = /*#__PURE__*/ createResourceParams$D(updateVisualization_ConfigPropertyMetadata);
 function typeCheckConfig$e(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, updateVisualization_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, updateVisualization_ConfigPropertyMetadata);
     const untrustedConfig_dataSource = untrustedConfig.dataSource;
     if (untrustedIsObject(untrustedConfig_dataSource)) {
         const untrustedConfig_dataSource_object = {};
@@ -6245,7 +6679,7 @@ function createResourceRequest$d(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/visualizations/' + config.urlParams.visualizationIdOrApiName + '/bundle',
+        basePath: '/tableau/visualizations/' + config.urlParams.visualizationIdOrApiName + '/bundle',
         method: 'get',
         body: null,
         urlParams: config.urlParams,
@@ -6260,14 +6694,14 @@ const getVisualizationBundle_ConfigPropertyMetadata = [
     generateParamConfigMetadata('visualizationIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getVisualizationBundle_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, getVisualizationBundle_ConfigPropertyMetadata);
-const createResourceParams$d = /*#__PURE__*/ createResourceParams$B(getVisualizationBundle_ConfigPropertyMetadata);
+const createResourceParams$d = /*#__PURE__*/ createResourceParams$D(getVisualizationBundle_ConfigPropertyMetadata);
 function keyBuilder$h(luvio, config) {
     const resourceParams = createResourceParams$d(config);
     return keyBuilder$i(luvio, resourceParams);
 }
 function typeCheckConfig$d(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getVisualizationBundle_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getVisualizationBundle_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
@@ -6316,7 +6750,7 @@ function buildNetworkSnapshot$d(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$d, undefined, false);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$d, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -6341,20 +6775,15 @@ const getVisualizationBundleAdapterFactory = (luvio) => function UnifiedAnalytic
     buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
 };
 
-const VERSION$7 = "d30aa567784494839ce9c37e69190918";
+const VERSION$7 = "1d72d9ce1a25023f80eef5daa23f140e";
 function validate$a(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$m(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$p(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');
@@ -6415,7 +6844,7 @@ function keyBuilder$g(luvio, config) {
 }
 function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
-        name: object.cacheableKey
+        name: object.name
     };
     return keyBuilder$g(luvio, keyParams);
 }
@@ -6589,7 +7018,7 @@ function createResourceRequest$c(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/workspaces',
+        basePath: '/tableau/workspaces',
         method: 'get',
         body: null,
         urlParams: {},
@@ -6605,14 +7034,14 @@ const getWorkspaces_ConfigPropertyMetadata = [
     generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
 ];
 const getWorkspaces_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, getWorkspaces_ConfigPropertyMetadata);
-const createResourceParams$c = /*#__PURE__*/ createResourceParams$B(getWorkspaces_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$D(getWorkspaces_ConfigPropertyMetadata);
 function keyBuilder$e(luvio, config) {
     const resourceParams = createResourceParams$c(config);
     return keyBuilder$f(luvio, resourceParams);
 }
 function typeCheckConfig$c(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getWorkspaces_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getWorkspaces_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
@@ -6661,7 +7090,7 @@ function buildNetworkSnapshot$c(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -6713,7 +7142,7 @@ function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/workspaces',
+        basePath: '/tableau/workspaces',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -6731,10 +7160,10 @@ const createWorkspace_ConfigPropertyMetadata = [
     generateParamConfigMetadata('name', false, 2 /* Body */, 0 /* String */),
 ];
 const createWorkspace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, createWorkspace_ConfigPropertyMetadata);
-const createResourceParams$b = /*#__PURE__*/ createResourceParams$B(createWorkspace_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$D(createWorkspace_ConfigPropertyMetadata);
 function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, createWorkspace_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, createWorkspace_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
@@ -6800,7 +7229,7 @@ function createResourceRequest$a(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/workspaces/' + config.urlParams.workspaceIdOrApiName + '',
+        basePath: '/tableau/workspaces/' + config.urlParams.workspaceIdOrApiName + '',
         method: 'delete',
         body: null,
         urlParams: config.urlParams,
@@ -6815,10 +7244,10 @@ const deleteWorkspace_ConfigPropertyMetadata = [
     generateParamConfigMetadata('workspaceIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteWorkspace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, deleteWorkspace_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$B(deleteWorkspace_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$D(deleteWorkspace_ConfigPropertyMetadata);
 function typeCheckConfig$a(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, deleteWorkspace_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, deleteWorkspace_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
@@ -6901,7 +7330,7 @@ function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/workspaces/' + config.urlParams.workspaceIdOrApiName + '',
+        basePath: '/tableau/workspaces/' + config.urlParams.workspaceIdOrApiName + '',
         method: 'get',
         body: null,
         urlParams: config.urlParams,
@@ -6916,14 +7345,14 @@ const getWorkspaceByIdOrName_ConfigPropertyMetadata = [
     generateParamConfigMetadata('workspaceIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getWorkspaceByIdOrName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getWorkspaceByIdOrName_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$B(getWorkspaceByIdOrName_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$D(getWorkspaceByIdOrName_ConfigPropertyMetadata);
 function keyBuilder$b(luvio, config) {
     const resourceParams = createResourceParams$9(config);
     return keyBuilder$c(luvio, resourceParams);
 }
 function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getWorkspaceByIdOrName_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getWorkspaceByIdOrName_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
@@ -6972,7 +7401,7 @@ function buildNetworkSnapshot$9(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -7024,7 +7453,7 @@ function createResourceRequest$8(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/workspaces/' + config.urlParams.workspaceIdOrApiName + '',
+        basePath: '/tableau/workspaces/' + config.urlParams.workspaceIdOrApiName + '',
         method: 'patch',
         body: config.body,
         urlParams: config.urlParams,
@@ -7043,10 +7472,10 @@ const updateWorkspace_ConfigPropertyMetadata = [
     generateParamConfigMetadata('name', false, 2 /* Body */, 0 /* String */),
 ];
 const updateWorkspace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, updateWorkspace_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$B(updateWorkspace_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$D(updateWorkspace_ConfigPropertyMetadata);
 function typeCheckConfig$8(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, updateWorkspace_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, updateWorkspace_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
@@ -7114,7 +7543,7 @@ function validate$8(obj, path = 'WorkspaceAssetRepresentation') {
         }
         const obj_createdBy = obj.createdBy;
         const path_createdBy = path + '.createdBy';
-        const referencepath_createdByValidationError = validate$m(obj_createdBy, path_createdBy);
+        const referencepath_createdByValidationError = validate$p(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');
@@ -7209,7 +7638,7 @@ function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/workspaces/' + config.urlParams.workspaceIdOrApiName + '/assets',
+        basePath: '/tableau/workspaces/' + config.urlParams.workspaceIdOrApiName + '/assets',
         method: 'post',
         body: config.body,
         urlParams: config.urlParams,
@@ -7227,10 +7656,10 @@ const createWorkspaceAsset_ConfigPropertyMetadata = [
     generateParamConfigMetadata('assetUsageType', true, 2 /* Body */, 0 /* String */),
 ];
 const createWorkspaceAsset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, createWorkspaceAsset_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$B(createWorkspaceAsset_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$D(createWorkspaceAsset_ConfigPropertyMetadata);
 function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, createWorkspaceAsset_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, createWorkspaceAsset_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
@@ -7296,7 +7725,7 @@ function createResourceRequest$6(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/workspaces/' + config.urlParams.workspaceIdOrApiName + '/assets/' + config.urlParams.assetId + '',
+        basePath: '/tableau/workspaces/' + config.urlParams.workspaceIdOrApiName + '/assets/' + config.urlParams.assetId + '',
         method: 'delete',
         body: null,
         urlParams: config.urlParams,
@@ -7312,10 +7741,10 @@ const deleteWorkspaceAsset_ConfigPropertyMetadata = [
     generateParamConfigMetadata('workspaceIdOrApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const deleteWorkspaceAsset_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, deleteWorkspaceAsset_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$B(deleteWorkspaceAsset_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$D(deleteWorkspaceAsset_ConfigPropertyMetadata);
 function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, deleteWorkspaceAsset_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, deleteWorkspaceAsset_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
@@ -7683,7 +8112,7 @@ function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/flows',
+        basePath: '/tableau/flows',
         method: 'get',
         body: null,
         urlParams: {},
@@ -7699,14 +8128,14 @@ const getFlows_ConfigPropertyMetadata = [
     generateParamConfigMetadata('offset', false, 1 /* QueryParameter */, 3 /* Integer */),
 ];
 const getFlows_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getFlows_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$B(getFlows_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$D(getFlows_ConfigPropertyMetadata);
 function keyBuilder$7(luvio, config) {
     const resourceParams = createResourceParams$5(config);
     return keyBuilder$8(luvio, resourceParams);
 }
 function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getFlows_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getFlows_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
@@ -7755,7 +8184,7 @@ function buildNetworkSnapshot$5(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
@@ -7816,7 +8245,7 @@ function createResourceRequest$4(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/flows/' + config.urlParams.flowApiName + '',
+        basePath: '/tableau/flows/' + config.urlParams.flowApiName + '',
         method: 'get',
         body: null,
         urlParams: config.urlParams,
@@ -7831,14 +8260,14 @@ const getFlowByName_ConfigPropertyMetadata = [
     generateParamConfigMetadata('flowApiName', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getFlowByName_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getFlowByName_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$B(getFlowByName_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$D(getFlowByName_ConfigPropertyMetadata);
 function keyBuilder$5(luvio, config) {
     const resourceParams = createResourceParams$4(config);
     return keyBuilder$6(luvio, resourceParams);
 }
 function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getFlowByName_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getFlowByName_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
@@ -7887,7 +8316,7 @@ function buildNetworkSnapshot$4(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { luvio, config } = context;
@@ -8030,7 +8459,7 @@ function createResourceRequest$3(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/subscriptions/digest/' + config.urlParams.digestConfigOwner + '',
+        basePath: '/tableau/subscriptions/digest/' + config.urlParams.digestConfigOwner + '',
         method: 'get',
         body: null,
         urlParams: config.urlParams,
@@ -8045,14 +8474,14 @@ const getSubscriptionDigestConfig_ConfigPropertyMetadata = [
     generateParamConfigMetadata('digestConfigOwner', true, 0 /* UrlParameter */, 0 /* String */),
 ];
 const getSubscriptionDigestConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getSubscriptionDigestConfig_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$B(getSubscriptionDigestConfig_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$D(getSubscriptionDigestConfig_ConfigPropertyMetadata);
 function keyBuilder$2(luvio, config) {
     const resourceParams = createResourceParams$3(config);
     return keyBuilder$3(luvio, resourceParams);
 }
 function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, getSubscriptionDigestConfig_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, getSubscriptionDigestConfig_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
@@ -8101,7 +8530,7 @@ function buildNetworkSnapshot$3(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
+    return buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -8153,7 +8582,7 @@ function createResourceRequest$2(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/subscriptions/digest/' + config.urlParams.digestConfigOwner + '',
+        basePath: '/tableau/subscriptions/digest/' + config.urlParams.digestConfigOwner + '',
         method: 'patch',
         body: config.body,
         urlParams: config.urlParams,
@@ -8170,10 +8599,10 @@ const updateSubscriptionDigestConfig_ConfigPropertyMetadata = [
     generateParamConfigMetadata('scheduleType', true, 2 /* Body */, 0 /* String */),
 ];
 const updateSubscriptionDigestConfig_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, updateSubscriptionDigestConfig_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$B(updateSubscriptionDigestConfig_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$D(updateSubscriptionDigestConfig_ConfigPropertyMetadata);
 function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, updateSubscriptionDigestConfig_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, updateSubscriptionDigestConfig_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
@@ -8384,7 +8813,7 @@ function createResourceRequest$1(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v62.0',
-        basePath: '/unified-analytics/library/assets/query',
+        basePath: '/tableau/library/assets/query',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -8403,7 +8832,7 @@ const getUnifiedAnalyticsLibraryAssets_ConfigPropertyMetadata = [
     generateParamConfigMetadata('searchToken', false, 2 /* Body */, 4 /* Unsupported */),
 ];
 const getUnifiedAnalyticsLibraryAssets_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getUnifiedAnalyticsLibraryAssets_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$B(getUnifiedAnalyticsLibraryAssets_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$D(getUnifiedAnalyticsLibraryAssets_ConfigPropertyMetadata);
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
     const untrustedConfig_assetTypes = untrustedConfig.assetTypes;
@@ -8637,10 +9066,10 @@ const generateSFDriveCredentials_ConfigPropertyMetadata = [
     generateParamConfigMetadata('path', true, 2 /* Body */, 0 /* String */),
 ];
 const generateSFDriveCredentials_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, generateSFDriveCredentials_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$B(generateSFDriveCredentials_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$D(generateSFDriveCredentials_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$B(untrustedConfig, config, generateSFDriveCredentials_ConfigPropertyMetadata);
+    typeCheckConfig$D(untrustedConfig, config, generateSFDriveCredentials_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -8685,4 +9114,4 @@ const generateSFDriveCredentialsAdapterFactory = (luvio) => {
     };
 };
 
-export { createAnnotationAdapterFactory, createAssetSlackChannelAdapterFactory, createDashboardAdapterFactory, createLoglinesAdapterFactory, createVisualizationAdapterFactory, createWorkspaceAdapterFactory, createWorkspaceAssetAdapterFactory, deleteDashboardAdapterFactory, deleteVisualizationAdapterFactory, deleteWorkspaceAdapterFactory, deleteWorkspaceAssetAdapterFactory, followAdapterFactory, generateSFDriveCredentialsAdapterFactory, getAnnotationsAdapterFactory, getAssetSlackChannelsAdapterFactory, getDashboardByNameAdapterFactory, getDashboardsAdapterFactory, getFlowByNameAdapterFactory, getFlowsAdapterFactory, getFollowedAssetsAdapterFactory, getFollowersAdapterFactory, getSlackAppInfoAdapterFactory, getSubscriptionDigestConfigAdapterFactory, getUnifiedAnalyticsLibraryAssetsAdapterFactory, getVisualizationAdapterFactory, getVisualizationBundleAdapterFactory, getVisualizationsAdapterFactory, getWorkspaceByIdOrNameAdapterFactory, getWorkspacesAdapterFactory, publishAdapterFactory, queryAssetsAdapterFactory, queryUsersAdapterFactory, unfollowAdapterFactory, updateDashboardAdapterFactory, updateSubscriptionDigestConfigAdapterFactory, updateVisualizationAdapterFactory, updateWorkspaceAdapterFactory };
+export { createAnnotationAdapterFactory, createAssetSlackChannelAdapterFactory, createDashboardAdapterFactory, createLoglinesAdapterFactory, createVisualizationAdapterFactory, createWorkspaceAdapterFactory, createWorkspaceAssetAdapterFactory, deleteDashboardAdapterFactory, deleteVisualizationAdapterFactory, deleteWorkspaceAdapterFactory, deleteWorkspaceAssetAdapterFactory, followAdapterFactory, generateSFDriveCredentialsAdapterFactory, getAnnotationsAdapterFactory, getAssetSlackChannelsAdapterFactory, getDashboardByNameAdapterFactory, getDashboardsAdapterFactory, getFlowByNameAdapterFactory, getFlowsAdapterFactory, getFollowedAssetsAdapterFactory, getFollowersAdapterFactory, getOrgAdapterFactory, getSlackAppInfoAdapterFactory, getSubscriptionDigestConfigAdapterFactory, getUnifiedAnalyticsLibraryAssetsAdapterFactory, getUniqueFollowerCountAdapterFactory, getVisualizationAdapterFactory, getVisualizationBundleAdapterFactory, getVisualizationsAdapterFactory, getWorkspaceByIdOrNameAdapterFactory, getWorkspacesAdapterFactory, publishAdapterFactory, queryAssetsAdapterFactory, queryUsersAdapterFactory, unfollowAdapterFactory, updateDashboardAdapterFactory, updateSubscriptionDigestConfigAdapterFactory, updateVisualizationAdapterFactory, updateWorkspaceAdapterFactory };