npm - @salesforce/lds-adapters-service-slack - Versions diffs - 1.335.0 → 1.337.0 - Mend

@salesforce/lds-adapters-service-slack 1.335.0 → 1.337.0

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

Files changed (11) hide show

package/dist/es/es2018/service-slack.js CHANGED Viewed

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$9, typeCheckConfig as typeCheckConfig$f, StoreKeyMap, createResourceParams as createResourceParams$f } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$a, typeCheckConfig as typeCheckConfig$g, StoreKeyMap, createResourceParams as createResourceParams$g } from '@luvio/engine';
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -111,8 +111,8 @@ function createLink(ref) {
     };
 }
-const VERSION$g = "9349aea0ef244c3f54fc857eb2d17577";
-function validate$g(obj, path = 'SlackSalesforceAuthenticationOutputRepresentation') {
+const VERSION$i = "9349aea0ef244c3f54fc857eb2d17577";
+function validate$i(obj, path = 'SlackSalesforceAuthenticationOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -125,14 +125,14 @@ function validate$g(obj, path = 'SlackSalesforceAuthenticationOutputRepresentati
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$d = 'SlackSalesforceAuthenticationOutputRepresentation';
-function normalize$c(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$f = 'SlackSalesforceAuthenticationOutputRepresentation';
+function normalize$e(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$t = function SlackSalesforceAuthenticationOutputRepresentationSelect() {
+const select$w = function SlackSalesforceAuthenticationOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$g,
+        version: VERSION$i,
         private: [],
         selections: [
             {
@@ -142,7 +142,7 @@ const select$t = function SlackSalesforceAuthenticationOutputRepresentationSelec
         ]
     };
 };
-function equals$g(existing, incoming) {
+function equals$i(existing, incoming) {
     const existing_authUrl = existing.authUrl;
     const incoming_authUrl = incoming.authUrl;
     if (!(existing_authUrl === incoming_authUrl)) {
@@ -150,44 +150,44 @@ function equals$g(existing, incoming) {
     }
     return true;
 }
-const ingest$c = function SlackSalesforceAuthenticationOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$e = function SlackSalesforceAuthenticationOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$g(input);
+        const validateError = validate$i(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$c, "Slack", VERSION$g, RepresentationType$d, equals$g);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$e, "Slack", VERSION$i, RepresentationType$f, equals$i);
     return createLink(key);
 };
-function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$e(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$d,
+        representationName: RepresentationType$f,
         mergeable: false
     });
 }
-function select$s(luvio, params) {
-    return select$t();
+function select$v(luvio, params) {
+    return select$w();
 }
-function keyBuilder$q(luvio, params) {
+function keyBuilder$t(luvio, params) {
     return keyPrefix + '::SlackSalesforceAuthenticationOutputRepresentation:(' + 'appId:' + params.queryParams.appId + ')';
 }
-function getResponseCacheKeys$e(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$c(storeKeyMap, luvio, response, () => keyBuilder$q(luvio, resourceParams));
+function getResponseCacheKeys$f(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$e(storeKeyMap, luvio, response, () => keyBuilder$t(luvio, resourceParams));
 }
-function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$d(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$q(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$c, body);
+    const key = keyBuilder$t(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$e, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$s(),
+        node: select$v(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -198,13 +198,13 @@ function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$8(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$q(luvio, params);
+function ingestError$9(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$t(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$e(config) {
+function createResourceRequest$f(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -218,94 +218,94 @@ function createResourceRequest$e(config) {
     };
 }
-const adapterName$e = 'getSlackSalesforceAuth';
+const adapterName$f = 'getSlackSalesforceAuth';
 const getSlackSalesforceAuth_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appId', true, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSlackSalesforceAuth_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, getSlackSalesforceAuth_ConfigPropertyMetadata);
-const createResourceParams$e = /*#__PURE__*/ createResourceParams$f(getSlackSalesforceAuth_ConfigPropertyMetadata);
-function keyBuilder$p(luvio, config) {
-    const resourceParams = createResourceParams$e(config);
-    return keyBuilder$q(luvio, resourceParams);
+const getSlackSalesforceAuth_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$f, getSlackSalesforceAuth_ConfigPropertyMetadata);
+const createResourceParams$f = /*#__PURE__*/ createResourceParams$g(getSlackSalesforceAuth_ConfigPropertyMetadata);
+function keyBuilder$s(luvio, config) {
+    const resourceParams = createResourceParams$f(config);
+    return keyBuilder$t(luvio, resourceParams);
 }
-function typeCheckConfig$e(untrustedConfig) {
+function typeCheckConfig$f(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getSlackSalesforceAuth_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getSlackSalesforceAuth_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$f(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$e(untrustedConfig);
+    const config = typeCheckConfig$f(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$8(luvio, config) {
-    createResourceParams$e(config);
-    return select$s();
+function adapterFragment$9(luvio, config) {
+    createResourceParams$f(config);
+    return select$v();
 }
-function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$c(luvio, resourceParams, response, {
+function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$d(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$8(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$8(luvio, resourceParams, response, {
+function onFetchResponseError$9(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$e(luvio, config, options) {
-    const resourceParams = createResourceParams$e(config);
-    const request = createResourceRequest$e(resourceParams);
+function buildNetworkSnapshot$f(luvio, config, options) {
+    const resourceParams = createResourceParams$f(config);
+    const request = createResourceRequest$f(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$9(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$e(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$f(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$8(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$9(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$e, undefined, false);
+function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$f, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$p(luvio, config),
-        node: adapterFragment$8(luvio, config),
+        recordId: keyBuilder$s(luvio, config),
+        node: adapterFragment$9(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSlackSalesforceAuthAdapterFactory = (luvio) => function Slack__getSlackSalesforceAuth(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$e(untrustedConfig, getSlackSalesforceAuth_ConfigPropertyNames);
+    const config = validateAdapterConfig$f(untrustedConfig, getSlackSalesforceAuth_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$8, buildNetworkSnapshotCachePolicy$8);
+    buildCachedSnapshotCachePolicy$9, buildNetworkSnapshotCachePolicy$9);
 };
-const VERSION$f = "c1bddf326dab5c5496dc81bd0e4d7e2e";
-function validate$f(obj, path = 'SlackCustomEmojisOutputRepresentation') {
+const VERSION$h = "c1bddf326dab5c5496dc81bd0e4d7e2e";
+function validate$h(obj, path = 'SlackCustomEmojisOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -332,14 +332,14 @@ function validate$f(obj, path = 'SlackCustomEmojisOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$c = 'SlackCustomEmojisOutputRepresentation';
-function normalize$b(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$e = 'SlackCustomEmojisOutputRepresentation';
+function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$r = function SlackCustomEmojisOutputRepresentationSelect() {
+const select$u = function SlackCustomEmojisOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$f,
+        version: VERSION$h,
         private: [],
         selections: [
             {
@@ -354,7 +354,7 @@ const select$r = function SlackCustomEmojisOutputRepresentationSelect() {
         ]
     };
 };
-function equals$f(existing, incoming) {
+function equals$h(existing, incoming) {
     const existing_teamId = existing.teamId;
     const incoming_teamId = incoming.teamId;
     if (!(existing_teamId === incoming_teamId)) {
@@ -372,44 +372,44 @@ function equals$f(existing, incoming) {
     }
     return true;
 }
-const ingest$b = function SlackCustomEmojisOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$d = function SlackCustomEmojisOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$f(input);
+        const validateError = validate$h(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$b, "Slack", VERSION$f, RepresentationType$c, equals$f);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$d, "Slack", VERSION$h, RepresentationType$e, equals$h);
     return createLink(key);
 };
-function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$c,
+        representationName: RepresentationType$e,
         mergeable: false
     });
 }
-function select$q(luvio, params) {
-    return select$r();
+function select$t(luvio, params) {
+    return select$u();
 }
-function keyBuilder$o(luvio, params) {
+function keyBuilder$r(luvio, params) {
     return keyPrefix + '::SlackCustomEmojisOutputRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'teamId:' + params.queryParams.teamId + ')';
 }
-function getResponseCacheKeys$d(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$b(storeKeyMap, luvio, response, () => keyBuilder$o(luvio, resourceParams));
+function getResponseCacheKeys$e(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$d(storeKeyMap, luvio, response, () => keyBuilder$r(luvio, resourceParams));
 }
-function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$c(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$o(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$b, body);
+    const key = keyBuilder$r(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$d, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$q(),
+        node: select$t(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -420,13 +420,13 @@ function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$7(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$o(luvio, params);
+function ingestError$8(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$r(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$d(config) {
+function createResourceRequest$e(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -440,95 +440,95 @@ function createResourceRequest$d(config) {
     };
 }
-const adapterName$d = 'getSlackCustomEmoji';
+const adapterName$e = 'getSlackCustomEmoji';
 const getSlackCustomEmoji_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSlackCustomEmoji_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, getSlackCustomEmoji_ConfigPropertyMetadata);
-const createResourceParams$d = /*#__PURE__*/ createResourceParams$f(getSlackCustomEmoji_ConfigPropertyMetadata);
-function keyBuilder$n(luvio, config) {
-    const resourceParams = createResourceParams$d(config);
-    return keyBuilder$o(luvio, resourceParams);
+const getSlackCustomEmoji_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$e, getSlackCustomEmoji_ConfigPropertyMetadata);
+const createResourceParams$e = /*#__PURE__*/ createResourceParams$g(getSlackCustomEmoji_ConfigPropertyMetadata);
+function keyBuilder$q(luvio, config) {
+    const resourceParams = createResourceParams$e(config);
+    return keyBuilder$r(luvio, resourceParams);
 }
-function typeCheckConfig$d(untrustedConfig) {
+function typeCheckConfig$e(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getSlackCustomEmoji_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getSlackCustomEmoji_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$e(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$d(untrustedConfig);
+    const config = typeCheckConfig$e(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$7(luvio, config) {
-    createResourceParams$d(config);
-    return select$q();
+function adapterFragment$8(luvio, config) {
+    createResourceParams$e(config);
+    return select$t();
 }
-function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
+function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$c(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$7(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$7(luvio, resourceParams, response, {
+function onFetchResponseError$8(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$d(luvio, config, options) {
-    const resourceParams = createResourceParams$d(config);
-    const request = createResourceRequest$d(resourceParams);
+function buildNetworkSnapshot$e(luvio, config, options) {
+    const resourceParams = createResourceParams$e(config);
+    const request = createResourceRequest$e(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$8(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$d(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$e(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$7(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$8(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$d, undefined, false);
+function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$e, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$n(luvio, config),
-        node: adapterFragment$7(luvio, config),
+        recordId: keyBuilder$q(luvio, config),
+        node: adapterFragment$8(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$d(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSlackCustomEmojiAdapterFactory = (luvio) => function Slack__getSlackCustomEmoji(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$d(untrustedConfig, getSlackCustomEmoji_ConfigPropertyNames);
+    const config = validateAdapterConfig$e(untrustedConfig, getSlackCustomEmoji_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$7);
+    buildCachedSnapshotCachePolicy$8, buildNetworkSnapshotCachePolicy$8);
 };
-const VERSION$e = "67b7fe6f8ee1967c58049a7212129bad";
-function validate$e(obj, path = 'FileTypeOutputRepresentation') {
+const VERSION$g = "67b7fe6f8ee1967c58049a7212129bad";
+function validate$g(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 + '")');
@@ -546,10 +546,10 @@ function validate$e(obj, path = 'FileTypeOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$p = function FileTypeOutputRepresentationSelect() {
+const select$s = function FileTypeOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$e,
+        version: VERSION$g,
         private: [],
         selections: [
             {
@@ -563,7 +563,7 @@ const select$p = function FileTypeOutputRepresentationSelect() {
         ]
     };
 };
-function equals$e(existing, incoming) {
+function equals$g(existing, incoming) {
     const existing_extension = existing.extension;
     const incoming_extension = incoming.extension;
     if (!(existing_extension === incoming_extension)) {
@@ -577,8 +577,8 @@ function equals$e(existing, incoming) {
     return true;
 }
-const VERSION$d = "73aa50e42c29769a00f9777e21b0e1d7";
-function validate$d(obj, path = 'ContentVersionOutputRepresentation') {
+const VERSION$f = "73aa50e42c29769a00f9777e21b0e1d7";
+function validate$f(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 + '")');
@@ -592,7 +592,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$g(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');
@@ -661,11 +661,11 @@ function validate$d(obj, path = 'ContentVersionOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$o = function ContentVersionOutputRepresentationSelect() {
-    const { selections: FileTypeOutputRepresentation__selections, opaque: FileTypeOutputRepresentation__opaque, } = select$p();
+const select$r = function ContentVersionOutputRepresentationSelect() {
+    const { selections: FileTypeOutputRepresentation__selections, opaque: FileTypeOutputRepresentation__opaque, } = select$s();
     return {
         kind: 'Fragment',
-        version: VERSION$d,
+        version: VERSION$f,
         private: [],
         selections: [
             {
@@ -697,7 +697,7 @@ const select$o = function ContentVersionOutputRepresentationSelect() {
         ]
     };
 };
-function equals$d(existing, incoming) {
+function equals$f(existing, incoming) {
     const existing_size = existing.size;
     const incoming_size = incoming.size;
     if (!(existing_size === incoming_size)) {
@@ -723,7 +723,7 @@ function equals$d(existing, incoming) {
     if (!(existing_filetype === incoming_filetype
         || (existing_filetype != null &&
             incoming_filetype != null &&
-            equals$e(existing_filetype, incoming_filetype)))) {
+            equals$g(existing_filetype, incoming_filetype)))) {
         return false;
     }
     const existing_versionUrl = existing.versionUrl;
@@ -734,15 +734,15 @@ function equals$d(existing, incoming) {
     return true;
 }
-const VERSION$c = "86dc45870c15b40e9591690f7fb1ac16";
-function validate$c(obj, path = 'ContentDocumentOutputRepresentation') {
+const VERSION$e = "86dc45870c15b40e9591690f7fb1ac16";
+function validate$e(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$g(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');
@@ -755,7 +755,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$f(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');
@@ -774,12 +774,12 @@ function validate$c(obj, path = 'ContentDocumentOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$n = function ContentDocumentOutputRepresentationSelect() {
-    const { selections: FileTypeOutputRepresentation__selections, opaque: FileTypeOutputRepresentation__opaque, } = select$p();
-    const { selections: ContentVersionOutputRepresentation__selections, opaque: ContentVersionOutputRepresentation__opaque, } = select$o();
+const select$q = function ContentDocumentOutputRepresentationSelect() {
+    const { selections: FileTypeOutputRepresentation__selections, opaque: FileTypeOutputRepresentation__opaque, } = select$s();
+    const { selections: ContentVersionOutputRepresentation__selections, opaque: ContentVersionOutputRepresentation__opaque, } = select$r();
     return {
         kind: 'Fragment',
-        version: VERSION$c,
+        version: VERSION$e,
         private: [],
         selections: [
             {
@@ -807,7 +807,7 @@ const select$n = function ContentDocumentOutputRepresentationSelect() {
         ]
     };
 };
-function equals$c(existing, incoming) {
+function equals$e(existing, incoming) {
     const existing_size = existing.size;
     const incoming_size = incoming.size;
     if (!(existing_size === incoming_size)) {
@@ -825,19 +825,19 @@ function equals$c(existing, incoming) {
     }
     const existing_filetype = existing.filetype;
     const incoming_filetype = incoming.filetype;
-    if (!(equals$e(existing_filetype, incoming_filetype))) {
+    if (!(equals$g(existing_filetype, incoming_filetype))) {
         return false;
     }
     const existing_latestPublishedVersion = existing.latestPublishedVersion;
     const incoming_latestPublishedVersion = incoming.latestPublishedVersion;
-    if (!(equals$d(existing_latestPublishedVersion, incoming_latestPublishedVersion))) {
+    if (!(equals$f(existing_latestPublishedVersion, incoming_latestPublishedVersion))) {
         return false;
     }
     return true;
 }
-const VERSION$b = "bb76a06cd8248e2edce70bc4fb6e4626";
-function validate$b(obj, path = 'SlackFileOutputRepresentation') {
+const VERSION$d = "bb76a06cd8248e2edce70bc4fb6e4626";
+function validate$d(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 + '")');
@@ -846,7 +846,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$e(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');
@@ -1008,24 +1008,24 @@ function validate$b(obj, path = 'SlackFileOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$b = 'SlackFileOutputRepresentation';
-function keyBuilder$m(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$b + ':' + (config.uniqueKey === null ? '' : config.uniqueKey);
+const RepresentationType$d = 'SlackFileOutputRepresentation';
+function keyBuilder$p(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$d + ':' + (config.uniqueKey === null ? '' : config.uniqueKey);
 }
-function keyBuilderFromType$5(luvio, object) {
+function keyBuilderFromType$6(luvio, object) {
     const keyParams = {
         uniqueKey: object.uniqueKey
     };
-    return keyBuilder$m(luvio, keyParams);
+    return keyBuilder$p(luvio, keyParams);
 }
-function normalize$a(input, existing, path, luvio, store, timestamp) {
+function normalize$c(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$m = function SlackFileOutputRepresentationSelect() {
-    const { selections: ContentDocumentOutputRepresentation__selections, opaque: ContentDocumentOutputRepresentation__opaque, } = select$n();
+const select$p = function SlackFileOutputRepresentationSelect() {
+    const { selections: ContentDocumentOutputRepresentation__selections, opaque: ContentDocumentOutputRepresentation__opaque, } = select$q();
     return {
         kind: 'Fragment',
-        version: VERSION$b,
+        version: VERSION$d,
         private: [],
         selections: [
             {
@@ -1077,7 +1077,7 @@ const select$m = function SlackFileOutputRepresentationSelect() {
         ]
     };
 };
-function equals$b(existing, incoming) {
+function equals$d(existing, incoming) {
     const existing_filetype = existing.filetype;
     const incoming_filetype = incoming.filetype;
     if (!(existing_filetype === incoming_filetype)) {
@@ -1113,7 +1113,7 @@ function equals$b(existing, incoming) {
     if (!(existing_contentDocument === incoming_contentDocument
         || (existing_contentDocument != null &&
             incoming_contentDocument != null &&
-            equals$c(existing_contentDocument, incoming_contentDocument)))) {
+            equals$e(existing_contentDocument, incoming_contentDocument)))) {
         return false;
     }
     const existing_size = existing.size;
@@ -1138,41 +1138,41 @@ function equals$b(existing, incoming) {
     }
     return true;
 }
-const ingest$a = function SlackFileOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$c = function SlackFileOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$b(input);
+        const validateError = validate$d(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$5(luvio, input);
+    const key = keyBuilderFromType$6(luvio, input);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 60000;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$a, "Slack", VERSION$b, RepresentationType$b, equals$b);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$c, "Slack", VERSION$d, RepresentationType$d, equals$d);
     return createLink(key);
 };
-function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$5(luvio, input);
+    const rootKey = keyBuilderFromType$6(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$b,
+        representationName: RepresentationType$d,
         mergeable: false
     });
 }
-function select$l(luvio, params) {
-    return select$m();
+function select$o(luvio, params) {
+    return select$p();
 }
-function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$a(storeKeyMap, luvio, response);
+function getResponseCacheKeys$d(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$c(storeKeyMap, luvio, response);
 }
-function ingestSuccess$a(luvio, resourceParams, response) {
+function ingestSuccess$b(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$5(luvio, body);
-    luvio.storeIngest(key, ingest$a, body);
+    const key = keyBuilderFromType$6(luvio, body);
+    luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$l(),
+        node: select$o(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -1183,7 +1183,7 @@ function ingestSuccess$a(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$c(config) {
+function createResourceRequest$d(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -1197,7 +1197,7 @@ function createResourceRequest$c(config) {
     };
 }
-const adapterName$c = 'postSlackFile';
+const adapterName$d = 'postSlackFile';
 const postSlackFile_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appId', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('base64EncodedFileData', true, 2 /* Body */, 0 /* String */),
@@ -1209,11 +1209,11 @@ const postSlackFile_ConfigPropertyMetadata = [
     generateParamConfigMetadata('threadTs', true, 2 /* Body */, 4 /* Unsupported */),
     generateParamConfigMetadata('title', true, 2 /* Body */, 0 /* String */),
 ];
-const postSlackFile_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, postSlackFile_ConfigPropertyMetadata);
-const createResourceParams$c = /*#__PURE__*/ createResourceParams$f(postSlackFile_ConfigPropertyMetadata);
-function typeCheckConfig$c(untrustedConfig) {
+const postSlackFile_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$d, postSlackFile_ConfigPropertyMetadata);
+const createResourceParams$d = /*#__PURE__*/ createResourceParams$g(postSlackFile_ConfigPropertyMetadata);
+function typeCheckConfig$d(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, postSlackFile_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, postSlackFile_ConfigPropertyMetadata);
     const untrustedConfig_threadTs = untrustedConfig.threadTs;
     if (typeof untrustedConfig_threadTs === 'string') {
         config.threadTs = untrustedConfig_threadTs;
@@ -1223,30 +1223,30 @@ function typeCheckConfig$c(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$d(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$c(untrustedConfig);
+    const config = typeCheckConfig$d(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$c(luvio, config, options) {
-    const resourceParams = createResourceParams$c(config);
-    const request = createResourceRequest$c(resourceParams);
+function buildNetworkSnapshot$d(luvio, config, options) {
+    const resourceParams = createResourceParams$d(config);
+    const request = createResourceRequest$d(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$a(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$b(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$d(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -1256,17 +1256,17 @@ function buildNetworkSnapshot$c(luvio, config, options) {
 }
 const postSlackFileAdapterFactory = (luvio) => {
     return function postSlackFile(untrustedConfig) {
-        const config = validateAdapterConfig$c(untrustedConfig, postSlackFile_ConfigPropertyNames);
+        const config = validateAdapterConfig$d(untrustedConfig, postSlackFile_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "postSlackFile"');
         }
-        return buildNetworkSnapshot$c(luvio, config);
+        return buildNetworkSnapshot$d(luvio, config);
     };
 };
-const VERSION$a = "3f50a4365904d17e52e2980cf0e2dae1";
-function validate$a(obj, path = 'SlackEmojiOutputRepresentation') {
+const VERSION$c = "3f50a4365904d17e52e2980cf0e2dae1";
+function validate$c(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 + '")');
@@ -1389,10 +1389,10 @@ function validate$a(obj, path = 'SlackEmojiOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$k = function SlackEmojiOutputRepresentationSelect() {
+const select$n = function SlackEmojiOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$a,
+        version: VERSION$c,
         private: [],
         selections: [
             {
@@ -1421,7 +1421,7 @@ const select$k = function SlackEmojiOutputRepresentationSelect() {
         ]
     };
 };
-function equals$a(existing, incoming) {
+function equals$c(existing, incoming) {
     const existing_name = existing.name;
     const incoming_name = incoming.name;
     if (!(existing_name === incoming_name)) {
@@ -1474,8 +1474,8 @@ function equals$a(existing, incoming) {
     return true;
 }
-const VERSION$9 = "211c714365ce34ef733d04a962d56adf";
-function validate$9(obj, path = 'SlackUserInfoOutputRepresentation') {
+const VERSION$b = "211c714365ce34ef733d04a962d56adf";
+function validate$b(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 + '")');
@@ -1802,7 +1802,7 @@ function validate$9(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$c(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');
@@ -1864,24 +1864,24 @@ function validate$9(obj, path = 'SlackUserInfoOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$a = 'SlackUserInfoOutputRepresentation';
-function keyBuilder$l(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$a + ':' + config.userId;
+const RepresentationType$c = 'SlackUserInfoOutputRepresentation';
+function keyBuilder$o(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$c + ':' + config.userId;
 }
-function keyBuilderFromType$4(luvio, object) {
+function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         userId: object.slackUserId
     };
-    return keyBuilder$l(luvio, keyParams);
+    return keyBuilder$o(luvio, keyParams);
 }
-function normalize$9(input, existing, path, luvio, store, timestamp) {
+function normalize$b(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$j = function SlackUserInfoOutputRepresentationSelect() {
-    const { selections: SlackEmojiOutputRepresentation__selections, opaque: SlackEmojiOutputRepresentation__opaque, } = select$k();
+const select$m = function SlackUserInfoOutputRepresentationSelect() {
+    const { selections: SlackEmojiOutputRepresentation__selections, opaque: SlackEmojiOutputRepresentation__opaque, } = select$n();
     return {
         kind: 'Fragment',
-        version: VERSION$9,
+        version: VERSION$b,
         private: [],
         selections: [
             {
@@ -1967,7 +1967,7 @@ const select$j = function SlackUserInfoOutputRepresentationSelect() {
         ]
     };
 };
-function equals$9(existing, incoming) {
+function equals$b(existing, incoming) {
     const existing_bot = existing.bot;
     const incoming_bot = incoming.bot;
     if (!(existing_bot === incoming_bot)) {
@@ -2119,7 +2119,7 @@ function equals$9(existing, incoming) {
         if (!(existing_statusEmoji === incoming_statusEmoji
             || (existing_statusEmoji != null &&
                 incoming_statusEmoji != null &&
-                equals$a(existing_statusEmoji, incoming_statusEmoji)))) {
+                equals$c(existing_statusEmoji, incoming_statusEmoji)))) {
             return false;
         }
     }
@@ -2138,31 +2138,31 @@ function equals$9(existing, incoming) {
     }
     return true;
 }
-const ingest$9 = function SlackUserInfoOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$b = function SlackUserInfoOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$9(input);
+        const validateError = validate$b(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$4(luvio, input);
+    const key = keyBuilderFromType$5(luvio, input);
     const ttlToUse = path.ttl !== undefined ? path.ttl : 60000;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$9, "Slack", VERSION$9, RepresentationType$a, equals$9);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$b, "Slack", VERSION$b, RepresentationType$c, equals$b);
     return createLink(key);
 };
-function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$4(luvio, input);
+    const rootKey = keyBuilderFromType$5(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$a,
+        representationName: RepresentationType$c,
         mergeable: false
     });
 }
 const TTL$3 = 100;
-const VERSION$8 = "0d8f9b582f9edf68d990e24110571988";
-function validate$8(obj, path = 'SlackReactionOutputRepresentation') {
+const VERSION$a = "0d8f9b582f9edf68d990e24110571988";
+function validate$a(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 + '")');
@@ -2327,25 +2327,25 @@ function validate$8(obj, path = 'SlackReactionOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$9 = 'SlackReactionOutputRepresentation';
-function keyBuilder$k(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$9 + ':' + config.messageTimestamp + ':' + config.name + ':' + (config.uniqueKey === null ? '' : config.uniqueKey);
+const RepresentationType$b = 'SlackReactionOutputRepresentation';
+function keyBuilder$n(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$b + ':' + config.messageTimestamp + ':' + config.name + ':' + (config.uniqueKey === null ? '' : config.uniqueKey);
 }
-function keyBuilderFromType$3(luvio, object) {
+function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         messageTimestamp: object.messageTs,
         name: object.name,
         uniqueKey: object.uniqueKey
     };
-    return keyBuilder$k(luvio, keyParams);
+    return keyBuilder$n(luvio, keyParams);
 }
-function normalize$8(input, existing, path, luvio, store, timestamp) {
+function normalize$a(input, existing, path, luvio, store, timestamp) {
     const input_reactedUsers = input.reactedUsers;
     const input_reactedUsers_id = path.fullPath + '__reactedUsers';
     for (let i = 0; i < input_reactedUsers.length; i++) {
         const input_reactedUsers_item = input_reactedUsers[i];
         let input_reactedUsers_item_id = input_reactedUsers_id + '__' + i;
-        input_reactedUsers[i] = ingest$9(input_reactedUsers_item, {
+        input_reactedUsers[i] = ingest$b(input_reactedUsers_item, {
             fullPath: input_reactedUsers_item_id,
             propertyName: i,
             parent: {
@@ -2358,10 +2358,10 @@ function normalize$8(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$i = function SlackReactionOutputRepresentationSelect() {
+const select$l = function SlackReactionOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$8,
+        version: VERSION$a,
         private: [],
         selections: [
             {
@@ -2388,7 +2388,7 @@ const select$i = function SlackReactionOutputRepresentationSelect() {
                 name: 'reactedUsers',
                 kind: 'Link',
                 plural: true,
-                fragment: select$j()
+                fragment: select$m()
             },
             {
                 name: 'unicode',
@@ -2405,7 +2405,7 @@ const select$i = function SlackReactionOutputRepresentationSelect() {
         ]
     };
 };
-function equals$8(existing, incoming) {
+function equals$a(existing, incoming) {
     const existing_hasUserReacted = existing.hasUserReacted;
     const incoming_hasUserReacted = incoming.hasUserReacted;
     if (!(existing_hasUserReacted === incoming_hasUserReacted)) {
@@ -2458,35 +2458,35 @@ function equals$8(existing, incoming) {
     }
     return true;
 }
-const ingest$8 = function SlackReactionOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$a = function SlackReactionOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$8(input);
+        const validateError = validate$a(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$3(luvio, input);
+    const key = keyBuilderFromType$4(luvio, input);
     const ttlToUse = TTL$3;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "Slack", VERSION$8, RepresentationType$9, equals$8);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$a, "Slack", VERSION$a, RepresentationType$b, equals$a);
     return createLink(key);
 };
-function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$3(luvio, input);
+    const rootKey = keyBuilderFromType$4(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$9,
+        representationName: RepresentationType$b,
         mergeable: false
     });
     const input_reactedUsers_length = input.reactedUsers.length;
     for (let i = 0; i < input_reactedUsers_length; i++) {
-        getTypeCacheKeys$9(rootKeySet, luvio, input.reactedUsers[i]);
+        getTypeCacheKeys$b(rootKeySet, luvio, input.reactedUsers[i]);
     }
 }
 const TTL$2 = 300;
-const VERSION$7 = "f13e32c2aedd6b70cf8a701ed37990b7";
-function validate$7(obj, path = 'SlackMessageOutputRepresentation') {
+const VERSION$9 = "f13e32c2aedd6b70cf8a701ed37990b7";
+function validate$9(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 + '")');
@@ -2867,23 +2867,23 @@ function validate$7(obj, path = 'SlackMessageOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$8 = 'SlackMessageOutputRepresentation';
-function keyBuilder$j(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$8 + ':' + config.messageTimestamp;
+const RepresentationType$a = 'SlackMessageOutputRepresentation';
+function keyBuilder$m(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$a + ':' + config.messageTimestamp;
 }
-function keyBuilderFromType$2(luvio, object) {
+function keyBuilderFromType$3(luvio, object) {
     const keyParams = {
         messageTimestamp: object.slackMessageTs
     };
-    return keyBuilder$j(luvio, keyParams);
+    return keyBuilder$m(luvio, keyParams);
 }
-function normalize$7(input, existing, path, luvio, store, timestamp) {
+function normalize$9(input, existing, path, luvio, store, timestamp) {
     const input_files = input.files;
     const input_files_id = path.fullPath + '__files';
     for (let i = 0; i < input_files.length; i++) {
         const input_files_item = input_files[i];
         let input_files_item_id = input_files_id + '__' + i;
-        input_files[i] = ingest$a(input_files_item, {
+        input_files[i] = ingest$c(input_files_item, {
             fullPath: input_files_item_id,
             propertyName: i,
             parent: {
@@ -2899,7 +2899,7 @@ function normalize$7(input, existing, path, luvio, store, timestamp) {
     for (let i = 0; i < input_reactions.length; i++) {
         const input_reactions_item = input_reactions[i];
         let input_reactions_item_id = input_reactions_id + '__' + i;
-        input_reactions[i] = ingest$8(input_reactions_item, {
+        input_reactions[i] = ingest$a(input_reactions_item, {
             fullPath: input_reactions_item_id,
             propertyName: i,
             parent: {
@@ -2915,7 +2915,7 @@ function normalize$7(input, existing, path, luvio, store, timestamp) {
     for (let i = 0; i < input_replyUsers.length; i++) {
         const input_replyUsers_item = input_replyUsers[i];
         let input_replyUsers_item_id = input_replyUsers_id + '__' + i;
-        input_replyUsers[i] = ingest$9(input_replyUsers_item, {
+        input_replyUsers[i] = ingest$b(input_replyUsers_item, {
             fullPath: input_replyUsers_item_id,
             propertyName: i,
             parent: {
@@ -2928,7 +2928,7 @@ function normalize$7(input, existing, path, luvio, store, timestamp) {
     }
     const input_userInfo = input.userInfo;
     const input_userInfo_id = path.fullPath + '__userInfo';
-    input.userInfo = ingest$9(input_userInfo, {
+    input.userInfo = ingest$b(input_userInfo, {
         fullPath: input_userInfo_id,
         propertyName: 'userInfo',
         parent: {
@@ -2940,10 +2940,10 @@ function normalize$7(input, existing, path, luvio, store, timestamp) {
     }, luvio, store, timestamp);
     return input;
 }
-const select$h = function SlackMessageOutputRepresentationSelect() {
+const select$k = function SlackMessageOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$7,
+        version: VERSION$9,
         private: [],
         selections: [
             {
@@ -2962,7 +2962,7 @@ const select$h = function SlackMessageOutputRepresentationSelect() {
                 name: 'files',
                 kind: 'Link',
                 plural: true,
-                fragment: select$m()
+                fragment: select$p()
             },
             {
                 name: 'includesCustomEmoji',
@@ -3004,7 +3004,7 @@ const select$h = function SlackMessageOutputRepresentationSelect() {
                 name: 'reactions',
                 kind: 'Link',
                 plural: true,
-                fragment: select$i()
+                fragment: select$l()
             },
             {
                 name: 'replyCount',
@@ -3014,7 +3014,7 @@ const select$h = function SlackMessageOutputRepresentationSelect() {
                 name: 'replyUsers',
                 kind: 'Link',
                 plural: true,
-                fragment: select$j()
+                fragment: select$m()
             },
             {
                 name: 'replyUsersCount',
@@ -3051,12 +3051,12 @@ const select$h = function SlackMessageOutputRepresentationSelect() {
             {
                 name: 'userInfo',
                 kind: 'Link',
-                fragment: select$j()
+                fragment: select$m()
             }
         ]
     };
 };
-function equals$7(existing, incoming) {
+function equals$9(existing, incoming) {
     const existing_isEditable = existing.isEditable;
     const incoming_isEditable = incoming.isEditable;
     if (!(existing_isEditable === incoming_isEditable)) {
@@ -3199,43 +3199,43 @@ function equals$7(existing, incoming) {
     }
     return true;
 }
-const ingest$7 = function SlackMessageOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$9 = function SlackMessageOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$7(input);
+        const validateError = validate$9(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$2(luvio, input);
+    const key = keyBuilderFromType$3(luvio, input);
     const ttlToUse = TTL$2;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$7, "Slack", VERSION$7, RepresentationType$8, equals$7);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$9, "Slack", VERSION$9, RepresentationType$a, equals$9);
     return createLink(key);
 };
-function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$2(luvio, input);
+    const rootKey = keyBuilderFromType$3(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$8,
+        representationName: RepresentationType$a,
         mergeable: false
     });
     const input_files_length = input.files.length;
     for (let i = 0; i < input_files_length; i++) {
-        getTypeCacheKeys$a(rootKeySet, luvio, input.files[i]);
+        getTypeCacheKeys$c(rootKeySet, luvio, input.files[i]);
     }
     const input_reactions_length = input.reactions.length;
     for (let i = 0; i < input_reactions_length; i++) {
-        getTypeCacheKeys$8(rootKeySet, luvio, input.reactions[i]);
+        getTypeCacheKeys$a(rootKeySet, luvio, input.reactions[i]);
     }
     const input_replyUsers_length = input.replyUsers.length;
     for (let i = 0; i < input_replyUsers_length; i++) {
-        getTypeCacheKeys$9(rootKeySet, luvio, input.replyUsers[i]);
+        getTypeCacheKeys$b(rootKeySet, luvio, input.replyUsers[i]);
     }
-    getTypeCacheKeys$9(rootKeySet, luvio, input.userInfo);
+    getTypeCacheKeys$b(rootKeySet, luvio, input.userInfo);
 }
-const VERSION$6 = "54b71fa43b81f03c9bf835539e0bdefc";
-function validate$6(obj, path = 'SlackConversationOutputRepresentation') {
+const VERSION$8 = "54b71fa43b81f03c9bf835539e0bdefc";
+function validate$8(obj, path = 'SlackConversationOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3379,11 +3379,11 @@ function validate$6(obj, path = 'SlackConversationOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$7 = 'SlackConversationOutputRepresentation';
-function normalize$6(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$9 = 'SlackConversationOutputRepresentation';
+function normalize$8(input, existing, path, luvio, store, timestamp) {
     const input_contextUserInfo = input.contextUserInfo;
     const input_contextUserInfo_id = path.fullPath + '__contextUserInfo';
-    input.contextUserInfo = ingest$9(input_contextUserInfo, {
+    input.contextUserInfo = ingest$b(input_contextUserInfo, {
         fullPath: input_contextUserInfo_id,
         propertyName: 'contextUserInfo',
         parent: {
@@ -3398,7 +3398,7 @@ function normalize$6(input, existing, path, luvio, store, timestamp) {
     for (let i = 0; i < input_messages.length; i++) {
         const input_messages_item = input_messages[i];
         let input_messages_item_id = input_messages_id + '__' + i;
-        input_messages[i] = ingest$7(input_messages_item, {
+        input_messages[i] = ingest$9(input_messages_item, {
             fullPath: input_messages_item_id,
             propertyName: i,
             parent: {
@@ -3411,10 +3411,10 @@ function normalize$6(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$g = function SlackConversationOutputRepresentationSelect() {
+const select$j = function SlackConversationOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$6,
+        version: VERSION$8,
         private: [],
         selections: [
             {
@@ -3428,7 +3428,7 @@ const select$g = function SlackConversationOutputRepresentationSelect() {
             {
                 name: 'contextUserInfo',
                 kind: 'Link',
-                fragment: select$j()
+                fragment: select$m()
             },
             {
                 name: 'hasMore',
@@ -3442,7 +3442,7 @@ const select$g = function SlackConversationOutputRepresentationSelect() {
                 name: 'messages',
                 kind: 'Link',
                 plural: true,
-                fragment: select$h()
+                fragment: select$k()
             },
             {
                 name: 'oldestMessageTs',
@@ -3459,7 +3459,7 @@ const select$g = function SlackConversationOutputRepresentationSelect() {
         ]
     };
 };
-function equals$6(existing, incoming) {
+function equals$8(existing, incoming) {
     const existing_appId = existing.appId;
     const incoming_appId = incoming.appId;
     if (!(existing_appId === incoming_appId)) {
@@ -3512,49 +3512,49 @@ function equals$6(existing, incoming) {
     }
     return true;
 }
-const ingest$6 = function SlackConversationOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$8 = function SlackConversationOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$6(input);
+        const validateError = validate$8(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$6, "Slack", VERSION$6, RepresentationType$7, equals$6);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "Slack", VERSION$8, RepresentationType$9, equals$8);
     return createLink(key);
 };
-function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$7,
+        representationName: RepresentationType$9,
         mergeable: false
     });
-    getTypeCacheKeys$9(rootKeySet, luvio, input.contextUserInfo);
+    getTypeCacheKeys$b(rootKeySet, luvio, input.contextUserInfo);
     const input_messages_length = input.messages.length;
     for (let i = 0; i < input_messages_length; i++) {
-        getTypeCacheKeys$7(rootKeySet, luvio, input.messages[i]);
+        getTypeCacheKeys$9(rootKeySet, luvio, input.messages[i]);
     }
 }
-function select$f(luvio, params) {
-    return select$g();
+function select$i(luvio, params) {
+    return select$j();
 }
-function keyBuilder$i(luvio, params) {
+function keyBuilder$l(luvio, params) {
     return keyPrefix + '::SlackConversationOutputRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'channelId:' + params.queryParams.channelId + ',' + 'latestMessageTs:' + params.queryParams.latestMessageTs + ',' + 'limit:' + params.queryParams.limit + ',' + 'parentMessageTs:' + params.queryParams.parentMessageTs + ',' + 'relatedRecordId:' + params.queryParams.relatedRecordId + ',' + 'teamId:' + params.queryParams.teamId + ')';
 }
-function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$6(storeKeyMap, luvio, response, () => keyBuilder$i(luvio, resourceParams));
+function getResponseCacheKeys$c(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$8(storeKeyMap, luvio, response, () => keyBuilder$l(luvio, resourceParams));
 }
-function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$a(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$i(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$6, body);
+    const key = keyBuilder$l(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$f(),
+        node: select$i(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -3565,13 +3565,13 @@ function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$6(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$i(luvio, params);
+function ingestError$7(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$l(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$b(config) {
+function createResourceRequest$c(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -3585,7 +3585,7 @@ function createResourceRequest$b(config) {
     };
 }
-const adapterName$b = 'getSlackConversation';
+const adapterName$c = 'getSlackConversation';
 const getSlackConversation_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('channelId', false, 1 /* QueryParameter */, 0 /* String */),
@@ -3595,91 +3595,91 @@ const getSlackConversation_ConfigPropertyMetadata = [
     generateParamConfigMetadata('relatedRecordId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSlackConversation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, getSlackConversation_ConfigPropertyMetadata);
-const createResourceParams$b = /*#__PURE__*/ createResourceParams$f(getSlackConversation_ConfigPropertyMetadata);
-function keyBuilder$h(luvio, config) {
-    const resourceParams = createResourceParams$b(config);
-    return keyBuilder$i(luvio, resourceParams);
+const getSlackConversation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$c, getSlackConversation_ConfigPropertyMetadata);
+const createResourceParams$c = /*#__PURE__*/ createResourceParams$g(getSlackConversation_ConfigPropertyMetadata);
+function keyBuilder$k(luvio, config) {
+    const resourceParams = createResourceParams$c(config);
+    return keyBuilder$l(luvio, resourceParams);
 }
-function typeCheckConfig$b(untrustedConfig) {
+function typeCheckConfig$c(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getSlackConversation_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getSlackConversation_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$b(untrustedConfig);
+    const config = typeCheckConfig$c(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$6(luvio, config) {
-    createResourceParams$b(config);
-    return select$f();
+function adapterFragment$7(luvio, config) {
+    createResourceParams$c(config);
+    return select$i();
 }
-function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
+function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$6(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$6(luvio, resourceParams, response, {
+function onFetchResponseError$7(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$b(luvio, config, options) {
-    const resourceParams = createResourceParams$b(config);
-    const request = createResourceRequest$b(resourceParams);
+function buildNetworkSnapshot$c(luvio, config, options) {
+    const resourceParams = createResourceParams$c(config);
+    const request = createResourceRequest$c(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$7(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$c(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$6(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$7(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$b, undefined, false);
+function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$h(luvio, config),
-        node: adapterFragment$6(luvio, config),
+        recordId: keyBuilder$k(luvio, config),
+        node: adapterFragment$7(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSlackConversationAdapterFactory = (luvio) => function Slack__getSlackConversation(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$b(untrustedConfig, getSlackConversation_ConfigPropertyNames);
+    const config = validateAdapterConfig$c(untrustedConfig, getSlackConversation_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$6);
+    buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$7);
 };
 const TTL$1 = 300;
-const VERSION$5 = "3fbe2a2b782a04407aa59b540ea5c4ba";
-function validate$5(obj, path = 'SlackPostMessageOutputRepresentation') {
+const VERSION$7 = "3fbe2a2b782a04407aa59b540ea5c4ba";
+function validate$7(obj, path = 'SlackPostMessageOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -3702,21 +3702,21 @@ function validate$5(obj, path = 'SlackPostMessageOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$6 = 'SlackPostMessageOutputRepresentation';
-function keyBuilder$g(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$6 + ':' + config.channelId + ':' + config.timestamp;
+const RepresentationType$8 = 'SlackPostMessageOutputRepresentation';
+function keyBuilder$j(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$8 + ':' + config.channelId + ':' + config.timestamp;
 }
-function keyBuilderFromType$1(luvio, object) {
+function keyBuilderFromType$2(luvio, object) {
     const keyParams = {
         channelId: object.channelId,
         timestamp: object.timestamp
     };
-    return keyBuilder$g(luvio, keyParams);
+    return keyBuilder$j(luvio, keyParams);
 }
-function normalize$5(input, existing, path, luvio, store, timestamp) {
+function normalize$7(input, existing, path, luvio, store, timestamp) {
     const input_postedMessage = input.postedMessage;
     const input_postedMessage_id = path.fullPath + '__postedMessage';
-    input.postedMessage = ingest$7(input_postedMessage, {
+    input.postedMessage = ingest$9(input_postedMessage, {
         fullPath: input_postedMessage_id,
         propertyName: 'postedMessage',
         parent: {
@@ -3728,10 +3728,10 @@ function normalize$5(input, existing, path, luvio, store, timestamp) {
     }, luvio, store, timestamp);
     return input;
 }
-const select$e = function SlackPostMessageOutputRepresentationSelect() {
+const select$h = function SlackPostMessageOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$5,
+        version: VERSION$7,
         private: [],
         selections: [
             {
@@ -3741,7 +3741,7 @@ const select$e = function SlackPostMessageOutputRepresentationSelect() {
             {
                 name: 'postedMessage',
                 kind: 'Link',
-                fragment: select$h()
+                fragment: select$k()
             },
             {
                 name: 'timestamp',
@@ -3750,7 +3750,7 @@ const select$e = function SlackPostMessageOutputRepresentationSelect() {
         ]
     };
 };
-function equals$5(existing, incoming) {
+function equals$7(existing, incoming) {
     const existing_channelId = existing.channelId;
     const incoming_channelId = incoming.channelId;
     if (!(existing_channelId === incoming_channelId)) {
@@ -3768,42 +3768,42 @@ function equals$5(existing, incoming) {
     }
     return true;
 }
-const ingest$5 = function SlackPostMessageOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$7 = function SlackPostMessageOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$5(input);
+        const validateError = validate$7(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$1(luvio, input);
+    const key = keyBuilderFromType$2(luvio, input);
     const ttlToUse = TTL$1;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "Slack", VERSION$5, RepresentationType$6, equals$5);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$7, "Slack", VERSION$7, RepresentationType$8, equals$7);
     return createLink(key);
 };
-function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$1(luvio, input);
+    const rootKey = keyBuilderFromType$2(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$6,
+        representationName: RepresentationType$8,
         mergeable: false
     });
-    getTypeCacheKeys$7(rootKeySet, luvio, input.postedMessage);
+    getTypeCacheKeys$9(rootKeySet, luvio, input.postedMessage);
 }
-function select$d(luvio, params) {
-    return select$e();
+function select$g(luvio, params) {
+    return select$h();
 }
-function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$5(storeKeyMap, luvio, response);
+function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$7(storeKeyMap, luvio, response);
 }
-function ingestSuccess$8(luvio, resourceParams, response) {
+function ingestSuccess$9(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$1(luvio, body);
-    luvio.storeIngest(key, ingest$5, body);
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$7, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$d(),
+        node: select$g(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -3814,7 +3814,7 @@ function ingestSuccess$8(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$a(config) {
+function createResourceRequest$b(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -3828,7 +3828,7 @@ function createResourceRequest$a(config) {
     };
 }
-const adapterName$a = 'postSlackConversation';
+const adapterName$b = 'postSlackConversation';
 const postSlackConversation_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appId', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('channelId', true, 2 /* Body */, 0 /* String */),
@@ -3838,11 +3838,11 @@ const postSlackConversation_ConfigPropertyMetadata = [
     generateParamConfigMetadata('text', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('threadTs', false, 2 /* Body */, 4 /* Unsupported */),
 ];
-const postSlackConversation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, postSlackConversation_ConfigPropertyMetadata);
-const createResourceParams$a = /*#__PURE__*/ createResourceParams$f(postSlackConversation_ConfigPropertyMetadata);
-function typeCheckConfig$a(untrustedConfig) {
+const postSlackConversation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, postSlackConversation_ConfigPropertyMetadata);
+const createResourceParams$b = /*#__PURE__*/ createResourceParams$g(postSlackConversation_ConfigPropertyMetadata);
+function typeCheckConfig$b(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, postSlackConversation_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, postSlackConversation_ConfigPropertyMetadata);
     const untrustedConfig_threadTs = untrustedConfig.threadTs;
     if (typeof untrustedConfig_threadTs === 'string') {
         config.threadTs = untrustedConfig_threadTs;
@@ -3852,30 +3852,30 @@ function typeCheckConfig$a(untrustedConfig) {
     }
     return config;
 }
-function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$a(untrustedConfig);
+    const config = typeCheckConfig$b(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$b(luvio, config, options) {
+    const resourceParams = createResourceParams$b(config);
+    const request = createResourceRequest$b(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$8(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$9(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$a(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$b(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -3885,33 +3885,33 @@ function buildNetworkSnapshot$a(luvio, config, options) {
 }
 const postSlackConversationAdapterFactory = (luvio) => {
     return function postSlackConversation(untrustedConfig) {
-        const config = validateAdapterConfig$a(untrustedConfig, postSlackConversation_ConfigPropertyNames);
+        const config = validateAdapterConfig$b(untrustedConfig, postSlackConversation_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "postSlackConversation"');
         }
-        return buildNetworkSnapshot$a(luvio, config);
+        return buildNetworkSnapshot$b(luvio, config);
     };
 };
-function keyBuilder$f(luvio, params) {
-    return keyBuilder$j(luvio, {
+function keyBuilder$i(luvio, params) {
+    return keyBuilder$m(luvio, {
         messageTimestamp: params.urlParams.messageTimestamp
     });
 }
-function getResponseCacheKeys$9(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$f(luvio, resourceParams);
+function getResponseCacheKeys$a(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$i(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$8,
+        representationName: RepresentationType$a,
         mergeable: false
     });
 }
 function evictSuccess$1(luvio, resourceParams) {
-    const key = keyBuilder$f(luvio, resourceParams);
+    const key = keyBuilder$i(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$9(config) {
+function createResourceRequest$a(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -3925,36 +3925,36 @@ function createResourceRequest$9(config) {
     };
 }
-const adapterName$9 = 'deleteSlackMessage';
+const adapterName$a = 'deleteSlackMessage';
 const deleteSlackMessage_ConfigPropertyMetadata = [
     generateParamConfigMetadata('messageTimestamp', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('channelId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const deleteSlackMessage_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, deleteSlackMessage_ConfigPropertyMetadata);
-const createResourceParams$9 = /*#__PURE__*/ createResourceParams$f(deleteSlackMessage_ConfigPropertyMetadata);
-function typeCheckConfig$9(untrustedConfig) {
+const deleteSlackMessage_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$a, deleteSlackMessage_ConfigPropertyMetadata);
+const createResourceParams$a = /*#__PURE__*/ createResourceParams$g(deleteSlackMessage_ConfigPropertyMetadata);
+function typeCheckConfig$a(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, deleteSlackMessage_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, deleteSlackMessage_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$a(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$9(untrustedConfig);
+    const config = typeCheckConfig$a(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$9(luvio, config, options) {
-    const resourceParams = createResourceParams$9(config);
-    const request = createResourceRequest$9(resourceParams);
+function buildNetworkSnapshot$a(luvio, config, options) {
+    const resourceParams = createResourceParams$a(config);
+    const request = createResourceRequest$a(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -3962,7 +3962,7 @@ function buildNetworkSnapshot$9(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$9(cache, luvio, resourceParams);
+            getResponseCacheKeys$a(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -3972,33 +3972,33 @@ function buildNetworkSnapshot$9(luvio, config, options) {
 }
 const deleteSlackMessageAdapterFactory = (luvio) => {
     return function SlackdeleteSlackMessage(untrustedConfig) {
-        const config = validateAdapterConfig$9(untrustedConfig, deleteSlackMessage_ConfigPropertyNames);
+        const config = validateAdapterConfig$a(untrustedConfig, deleteSlackMessage_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$9}"`);
+            throw new Error(`Invalid config for "${adapterName$a}"`);
         }
-        return buildNetworkSnapshot$9(luvio, config);
+        return buildNetworkSnapshot$a(luvio, config);
     };
 };
-function select$c(luvio, params) {
-    return select$h();
+function select$f(luvio, params) {
+    return select$k();
 }
-function keyBuilder$e(luvio, params) {
-    return keyBuilder$j(luvio, {
+function keyBuilder$h(luvio, params) {
+    return keyBuilder$m(luvio, {
         messageTimestamp: params.urlParams.messageTimestamp
     });
 }
-function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$7(storeKeyMap, luvio, response);
+function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$9(storeKeyMap, luvio, response);
 }
-function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$e(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$7, body);
+    const key = keyBuilder$h(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$9, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$c(),
+        node: select$f(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -4009,19 +4009,19 @@ function ingestSuccess$7(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$5(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$e(luvio, params);
+function ingestError$6(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$h(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$2,
         namespace: keyPrefix,
-        version: VERSION$7,
-        representationName: RepresentationType$8
+        version: VERSION$9,
+        representationName: RepresentationType$a
     };
     luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
     return errorSnapshot;
 }
-function createResourceRequest$8(config) {
+function createResourceRequest$9(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -4035,7 +4035,7 @@ function createResourceRequest$8(config) {
     };
 }
-const adapterName$8 = 'getSlackMessage';
+const adapterName$9 = 'getSlackMessage';
 const getSlackMessage_ConfigPropertyMetadata = [
     generateParamConfigMetadata('messageTimestamp', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
@@ -4044,91 +4044,91 @@ const getSlackMessage_ConfigPropertyMetadata = [
     generateParamConfigMetadata('relatedRecordId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSlackMessage_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getSlackMessage_ConfigPropertyMetadata);
-const createResourceParams$8 = /*#__PURE__*/ createResourceParams$f(getSlackMessage_ConfigPropertyMetadata);
-function keyBuilder$d(luvio, config) {
-    const resourceParams = createResourceParams$8(config);
-    return keyBuilder$e(luvio, resourceParams);
+const getSlackMessage_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getSlackMessage_ConfigPropertyMetadata);
+const createResourceParams$9 = /*#__PURE__*/ createResourceParams$g(getSlackMessage_ConfigPropertyMetadata);
+function keyBuilder$g(luvio, config) {
+    const resourceParams = createResourceParams$9(config);
+    return keyBuilder$h(luvio, resourceParams);
 }
-function typeCheckConfig$8(untrustedConfig) {
+function typeCheckConfig$9(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getSlackMessage_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getSlackMessage_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$9(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8(untrustedConfig);
+    const config = typeCheckConfig$9(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$5(luvio, config) {
-    createResourceParams$8(config);
-    return select$c();
+function adapterFragment$6(luvio, config) {
+    createResourceParams$9(config);
+    return select$f();
 }
-function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
+function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$5(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$5(luvio, resourceParams, response, {
+function onFetchResponseError$6(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$8(luvio, config, options) {
-    const resourceParams = createResourceParams$8(config);
-    const request = createResourceRequest$8(resourceParams);
+function buildNetworkSnapshot$9(luvio, config, options) {
+    const resourceParams = createResourceParams$9(config);
+    const request = createResourceRequest$9(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$9(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$6(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$8, undefined, false);
+function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$d(luvio, config),
-        node: adapterFragment$5(luvio, config),
+        recordId: keyBuilder$g(luvio, config),
+        node: adapterFragment$6(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$8(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSlackMessageAdapterFactory = (luvio) => function Slack__getSlackMessage(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$8(untrustedConfig, getSlackMessage_ConfigPropertyNames);
+    const config = validateAdapterConfig$9(untrustedConfig, getSlackMessage_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
+    buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$6);
 };
 const TTL = 300;
-const VERSION$4 = "e0dc0ed06034e8a0dcff97612151271f";
-function validate$4(obj, path = 'SlackUpdatedMessageOutputRepresentation') {
+const VERSION$6 = "e0dc0ed06034e8a0dcff97612151271f";
+function validate$6(obj, path = 'SlackUpdatedMessageOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4151,21 +4151,21 @@ function validate$4(obj, path = 'SlackUpdatedMessageOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$5 = 'SlackUpdatedMessageOutputRepresentation';
-function keyBuilder$c(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$5 + ':' + config.channelId + ':' + config.timestamp;
+const RepresentationType$7 = 'SlackUpdatedMessageOutputRepresentation';
+function keyBuilder$f(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$7 + ':' + config.channelId + ':' + config.timestamp;
 }
-function keyBuilderFromType(luvio, object) {
+function keyBuilderFromType$1(luvio, object) {
     const keyParams = {
         channelId: object.channelId,
         timestamp: object.timestamp
     };
-    return keyBuilder$c(luvio, keyParams);
+    return keyBuilder$f(luvio, keyParams);
 }
-function normalize$4(input, existing, path, luvio, store, timestamp) {
+function normalize$6(input, existing, path, luvio, store, timestamp) {
     const input_updatedMessage = input.updatedMessage;
     const input_updatedMessage_id = path.fullPath + '__updatedMessage';
-    input.updatedMessage = ingest$7(input_updatedMessage, {
+    input.updatedMessage = ingest$9(input_updatedMessage, {
         fullPath: input_updatedMessage_id,
         propertyName: 'updatedMessage',
         parent: {
@@ -4177,10 +4177,10 @@ function normalize$4(input, existing, path, luvio, store, timestamp) {
     }, luvio, store, timestamp);
     return input;
 }
-const select$b = function SlackUpdatedMessageOutputRepresentationSelect() {
+const select$e = function SlackUpdatedMessageOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$4,
+        version: VERSION$6,
         private: [],
         selections: [
             {
@@ -4194,12 +4194,12 @@ const select$b = function SlackUpdatedMessageOutputRepresentationSelect() {
             {
                 name: 'updatedMessage',
                 kind: 'Link',
-                fragment: select$h()
+                fragment: select$k()
             }
         ]
     };
 };
-function equals$4(existing, incoming) {
+function equals$6(existing, incoming) {
     const existing_channelId = existing.channelId;
     const incoming_channelId = incoming.channelId;
     if (!(existing_channelId === incoming_channelId)) {
@@ -4217,42 +4217,42 @@ function equals$4(existing, incoming) {
     }
     return true;
 }
-const ingest$4 = function SlackUpdatedMessageOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$6 = function SlackUpdatedMessageOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$4(input);
+        const validateError = validate$6(input);
         if (validateError !== null) {
             throw validateError;
         }
     }
-    const key = keyBuilderFromType(luvio, input);
+    const key = keyBuilderFromType$1(luvio, input);
     const ttlToUse = TTL;
-    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "Slack", VERSION$4, RepresentationType$5, equals$4);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$6, "Slack", VERSION$6, RepresentationType$7, equals$6);
     return createLink(key);
 };
-function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$6(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType(luvio, input);
+    const rootKey = keyBuilderFromType$1(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$5,
+        representationName: RepresentationType$7,
         mergeable: false
     });
-    getTypeCacheKeys$7(rootKeySet, luvio, input.updatedMessage);
+    getTypeCacheKeys$9(rootKeySet, luvio, input.updatedMessage);
 }
-function select$a(luvio, params) {
-    return select$b();
+function select$d(luvio, params) {
+    return select$e();
 }
-function getResponseCacheKeys$7(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$4(storeKeyMap, luvio, response);
+function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$6(storeKeyMap, luvio, response);
 }
-function ingestSuccess$6(luvio, resourceParams, response) {
+function ingestSuccess$7(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType(luvio, body);
-    luvio.storeIngest(key, ingest$4, body);
+    const key = keyBuilderFromType$1(luvio, body);
+    luvio.storeIngest(key, ingest$6, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$a(),
+        node: select$d(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -4263,7 +4263,7 @@ function ingestSuccess$6(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$7(config) {
+function createResourceRequest$8(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -4277,7 +4277,7 @@ function createResourceRequest$7(config) {
     };
 }
-const adapterName$7 = 'patchSlackMessage';
+const adapterName$8 = 'patchSlackMessage';
 const patchSlackMessage_ConfigPropertyMetadata = [
     generateParamConfigMetadata('messageTimestamp', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('appId', true, 2 /* Body */, 0 /* String */),
@@ -4285,37 +4285,37 @@ const patchSlackMessage_ConfigPropertyMetadata = [
     generateParamConfigMetadata('teamId', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('text', true, 2 /* Body */, 0 /* String */),
 ];
-const patchSlackMessage_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, patchSlackMessage_ConfigPropertyMetadata);
-const createResourceParams$7 = /*#__PURE__*/ createResourceParams$f(patchSlackMessage_ConfigPropertyMetadata);
-function typeCheckConfig$7(untrustedConfig) {
+const patchSlackMessage_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, patchSlackMessage_ConfigPropertyMetadata);
+const createResourceParams$8 = /*#__PURE__*/ createResourceParams$g(patchSlackMessage_ConfigPropertyMetadata);
+function typeCheckConfig$8(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, patchSlackMessage_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, patchSlackMessage_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$7(untrustedConfig);
+    const config = typeCheckConfig$8(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$7(luvio, config, options) {
-    const resourceParams = createResourceParams$7(config);
-    const request = createResourceRequest$7(resourceParams);
+function buildNetworkSnapshot$8(luvio, config, options) {
+    const resourceParams = createResourceParams$8(config);
+    const request = createResourceRequest$8(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$6(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$7(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$7(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$8(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -4325,38 +4325,38 @@ function buildNetworkSnapshot$7(luvio, config, options) {
 }
 const patchSlackMessageAdapterFactory = (luvio) => {
     return function patchSlackMessage(untrustedConfig) {
-        const config = validateAdapterConfig$7(untrustedConfig, patchSlackMessage_ConfigPropertyNames);
+        const config = validateAdapterConfig$8(untrustedConfig, patchSlackMessage_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "patchSlackMessage"');
         }
-        return buildNetworkSnapshot$7(luvio, config);
+        return buildNetworkSnapshot$8(luvio, config);
     };
 };
-const RepresentationType$4 = 'SlackReactionsOutputRepresentation';
-function keyBuilder$b(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$4 + ':' + config.messageTimestamp;
+const RepresentationType$6 = 'SlackReactionsOutputRepresentation';
+function keyBuilder$e(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$6 + ':' + config.messageTimestamp;
 }
-function keyBuilder$a(luvio, params) {
-    return keyBuilder$b(luvio, {
+function keyBuilder$d(luvio, params) {
+    return keyBuilder$e(luvio, {
         messageTimestamp: params.urlParams.messageTimestamp
     });
 }
-function getResponseCacheKeys$6(cacheKeyMap, luvio, resourceParams) {
-    const key = keyBuilder$a(luvio, resourceParams);
+function getResponseCacheKeys$7(cacheKeyMap, luvio, resourceParams) {
+    const key = keyBuilder$d(luvio, resourceParams);
     cacheKeyMap.set(key, {
         namespace: keyPrefix,
-        representationName: RepresentationType$4,
+        representationName: RepresentationType$6,
         mergeable: false
     });
 }
 function evictSuccess(luvio, resourceParams) {
-    const key = keyBuilder$a(luvio, resourceParams);
+    const key = keyBuilder$d(luvio, resourceParams);
     luvio.storeEvict(key);
 }
-function createResourceRequest$6(config) {
+function createResourceRequest$7(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -4370,7 +4370,7 @@ function createResourceRequest$6(config) {
     };
 }
-const adapterName$6 = 'deleteSlackMessageReactions';
+const adapterName$7 = 'deleteSlackMessageReactions';
 const deleteSlackMessageReactions_ConfigPropertyMetadata = [
     generateParamConfigMetadata('messageTimestamp', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
@@ -4378,29 +4378,29 @@ const deleteSlackMessageReactions_ConfigPropertyMetadata = [
     generateParamConfigMetadata('name', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const deleteSlackMessageReactions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, deleteSlackMessageReactions_ConfigPropertyMetadata);
-const createResourceParams$6 = /*#__PURE__*/ createResourceParams$f(deleteSlackMessageReactions_ConfigPropertyMetadata);
-function typeCheckConfig$6(untrustedConfig) {
+const deleteSlackMessageReactions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$7, deleteSlackMessageReactions_ConfigPropertyMetadata);
+const createResourceParams$7 = /*#__PURE__*/ createResourceParams$g(deleteSlackMessageReactions_ConfigPropertyMetadata);
+function typeCheckConfig$7(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, deleteSlackMessageReactions_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, deleteSlackMessageReactions_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$6(untrustedConfig);
+    const config = typeCheckConfig$7(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$6(luvio, config, options) {
-    const resourceParams = createResourceParams$6(config);
-    const request = createResourceRequest$6(resourceParams);
+function buildNetworkSnapshot$7(luvio, config, options) {
+    const resourceParams = createResourceParams$7(config);
+    const request = createResourceRequest$7(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then(() => {
         return luvio.handleSuccessResponse(() => {
@@ -4408,7 +4408,7 @@ function buildNetworkSnapshot$6(luvio, config, options) {
             return luvio.storeBroadcast();
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$6(cache, luvio, resourceParams);
+            getResponseCacheKeys$7(cache, luvio, resourceParams);
             return cache;
         });
     }, (response) => {
@@ -4418,28 +4418,28 @@ function buildNetworkSnapshot$6(luvio, config, options) {
 }
 const deleteSlackMessageReactionsAdapterFactory = (luvio) => {
     return function SlackdeleteSlackMessageReactions(untrustedConfig) {
-        const config = validateAdapterConfig$6(untrustedConfig, deleteSlackMessageReactions_ConfigPropertyNames);
+        const config = validateAdapterConfig$7(untrustedConfig, deleteSlackMessageReactions_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$6}"`);
+            throw new Error(`Invalid config for "${adapterName$7}"`);
         }
-        return buildNetworkSnapshot$6(luvio, config);
+        return buildNetworkSnapshot$7(luvio, config);
     };
 };
-function select$9(luvio, params) {
-    return select$i();
+function select$c(luvio, params) {
+    return select$l();
 }
-function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$8(storeKeyMap, luvio, response);
+function getResponseCacheKeys$6(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$a(storeKeyMap, luvio, response);
 }
-function ingestSuccess$5(luvio, resourceParams, response) {
+function ingestSuccess$6(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$3(luvio, body);
-    luvio.storeIngest(key, ingest$8, body);
+    const key = keyBuilderFromType$4(luvio, body);
+    luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$9(),
+        node: select$c(),
         variables: {},
     });
     if (process.env.NODE_ENV !== 'production') {
@@ -4450,7 +4450,7 @@ function ingestSuccess$5(luvio, resourceParams, response) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function createResourceRequest$5(config) {
+function createResourceRequest$6(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -4464,7 +4464,7 @@ function createResourceRequest$5(config) {
     };
 }
-const adapterName$5 = 'postSlackMessageReactions';
+const adapterName$6 = 'postSlackMessageReactions';
 const postSlackMessageReactions_ConfigPropertyMetadata = [
     generateParamConfigMetadata('messageTimestamp', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('appId', true, 2 /* Body */, 0 /* String */),
@@ -4472,37 +4472,37 @@ const postSlackMessageReactions_ConfigPropertyMetadata = [
     generateParamConfigMetadata('name', true, 2 /* Body */, 0 /* String */),
     generateParamConfigMetadata('teamId', true, 2 /* Body */, 0 /* String */),
 ];
-const postSlackMessageReactions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, postSlackMessageReactions_ConfigPropertyMetadata);
-const createResourceParams$5 = /*#__PURE__*/ createResourceParams$f(postSlackMessageReactions_ConfigPropertyMetadata);
-function typeCheckConfig$5(untrustedConfig) {
+const postSlackMessageReactions_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$6, postSlackMessageReactions_ConfigPropertyMetadata);
+const createResourceParams$6 = /*#__PURE__*/ createResourceParams$g(postSlackMessageReactions_ConfigPropertyMetadata);
+function typeCheckConfig$6(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, postSlackMessageReactions_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, postSlackMessageReactions_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$6(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$5(untrustedConfig);
+    const config = typeCheckConfig$6(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function buildNetworkSnapshot$5(luvio, config, options) {
-    const resourceParams = createResourceParams$5(config);
-    const request = createResourceRequest$5(resourceParams);
+function buildNetworkSnapshot$6(luvio, config, options) {
+    const resourceParams = createResourceParams$6(config);
+    const request = createResourceRequest$6(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => {
-            const snapshot = ingestSuccess$5(luvio, resourceParams, response);
+            const snapshot = ingestSuccess$6(luvio, resourceParams, response);
             return luvio.storeBroadcast().then(() => snapshot);
         }, () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$6(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
@@ -4512,33 +4512,33 @@ function buildNetworkSnapshot$5(luvio, config, options) {
 }
 const postSlackMessageReactionsAdapterFactory = (luvio) => {
     return function postSlackMessageReactions(untrustedConfig) {
-        const config = validateAdapterConfig$5(untrustedConfig, postSlackMessageReactions_ConfigPropertyNames);
+        const config = validateAdapterConfig$6(untrustedConfig, postSlackMessageReactions_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             throw new Error('Invalid config for "postSlackMessageReactions"');
         }
-        return buildNetworkSnapshot$5(luvio, config);
+        return buildNetworkSnapshot$6(luvio, config);
     };
 };
-function select$8(luvio, params) {
-    return select$j();
+function select$b(luvio, params) {
+    return select$m();
 }
-function keyBuilder$9(luvio, params) {
-    return keyBuilder$l(luvio, {
+function keyBuilder$c(luvio, params) {
+    return keyBuilder$o(luvio, {
         userId: params.urlParams.userId
     });
 }
-function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$9(storeKeyMap, luvio, response);
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$b(storeKeyMap, luvio, response);
 }
-function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$9(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$9, body);
+    const key = keyBuilder$c(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$8(),
+        node: select$b(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -4549,13 +4549,13 @@ function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$4(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$9(luvio, params);
+function ingestError$5(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$c(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$4(config) {
+function createResourceRequest$5(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -4569,96 +4569,96 @@ function createResourceRequest$4(config) {
     };
 }
-const adapterName$4 = 'getSlackUser';
+const adapterName$5 = 'getSlackUser';
 const getSlackUser_ConfigPropertyMetadata = [
     generateParamConfigMetadata('userId', true, 0 /* UrlParameter */, 0 /* String */),
     generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSlackUser_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getSlackUser_ConfigPropertyMetadata);
-const createResourceParams$4 = /*#__PURE__*/ createResourceParams$f(getSlackUser_ConfigPropertyMetadata);
-function keyBuilder$8(luvio, config) {
-    const resourceParams = createResourceParams$4(config);
-    return keyBuilder$9(luvio, resourceParams);
+const getSlackUser_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$5, getSlackUser_ConfigPropertyMetadata);
+const createResourceParams$5 = /*#__PURE__*/ createResourceParams$g(getSlackUser_ConfigPropertyMetadata);
+function keyBuilder$b(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$c(luvio, resourceParams);
 }
-function typeCheckConfig$4(untrustedConfig) {
+function typeCheckConfig$5(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getSlackUser_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getSlackUser_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$4(untrustedConfig);
+    const config = typeCheckConfig$5(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$4(luvio, config) {
-    createResourceParams$4(config);
-    return select$8();
+function adapterFragment$5(luvio, config) {
+    createResourceParams$5(config);
+    return select$b();
 }
-function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
+function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$4(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$4(luvio, resourceParams, response, {
+function onFetchResponseError$5(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$4(luvio, config, options) {
-    const resourceParams = createResourceParams$4(config);
-    const request = createResourceRequest$4(resourceParams);
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$5(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
+function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$5, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$8(luvio, config),
-        node: adapterFragment$4(luvio, config),
+        recordId: keyBuilder$b(luvio, config),
+        node: adapterFragment$5(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSlackUserAdapterFactory = (luvio) => function Slack__getSlackUser(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$4(untrustedConfig, getSlackUser_ConfigPropertyNames);
+    const config = validateAdapterConfig$5(untrustedConfig, getSlackUser_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
+    buildCachedSnapshotCachePolicy$5, buildNetworkSnapshotCachePolicy$5);
 };
-const VERSION$3 = "404a1b5e032907ee5acb8a57b59de85e";
-function validate$3(obj, path = 'SlackConversationInfoOutputRepresentation') {
+const VERSION$5 = "404a1b5e032907ee5acb8a57b59de85e";
+function validate$5(obj, path = 'SlackConversationInfoOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -4988,14 +4988,14 @@ function validate$3(obj, path = 'SlackConversationInfoOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$3 = 'SlackConversationInfoOutputRepresentation';
-function normalize$3(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$5 = 'SlackConversationInfoOutputRepresentation';
+function normalize$5(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$7 = function SlackConversationInfoOutputRepresentationSelect() {
+const select$a = function SlackConversationInfoOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$3,
+        version: VERSION$5,
         private: [],
         selections: [
             {
@@ -5057,7 +5057,7 @@ const select$7 = function SlackConversationInfoOutputRepresentationSelect() {
         ]
     };
 };
-function equals$3(existing, incoming) {
+function equals$5(existing, incoming) {
     const existing_id = existing.id;
     const incoming_id = incoming.id;
     if (!(existing_id === incoming_id)) {
@@ -5130,44 +5130,44 @@ function equals$3(existing, incoming) {
     }
     return true;
 }
-const ingest$3 = function SlackConversationInfoOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$5 = function SlackConversationInfoOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$3(input);
+        const validateError = validate$5(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$3, "Slack", VERSION$3, RepresentationType$3, equals$3);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$5, "Slack", VERSION$5, RepresentationType$5, equals$5);
     return createLink(key);
 };
-function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$5(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$3,
+        representationName: RepresentationType$5,
         mergeable: false
     });
 }
-function select$6(luvio, params) {
-    return select$7();
+function select$9(luvio, params) {
+    return select$a();
 }
-function keyBuilder$7(luvio, params) {
+function keyBuilder$a(luvio, params) {
     return keyPrefix + '::SlackConversationInfoOutputRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'channelId:' + params.queryParams.channelId + ',' + 'teamId:' + params.queryParams.teamId + ')';
 }
-function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$3(storeKeyMap, luvio, response, () => keyBuilder$7(luvio, resourceParams));
+function getResponseCacheKeys$4(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$5(storeKeyMap, luvio, response, () => keyBuilder$a(luvio, resourceParams));
 }
-function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$4(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$7(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$3, body);
+    const key = keyBuilder$a(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$5, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$6(),
+        node: select$9(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5178,13 +5178,13 @@ function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$3(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$7(luvio, params);
+function ingestError$4(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$a(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$3(config) {
+function createResourceRequest$4(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -5198,96 +5198,96 @@ function createResourceRequest$3(config) {
     };
 }
-const adapterName$3 = 'getSlackConversationInfo';
+const adapterName$4 = 'getSlackConversationInfo';
 const getSlackConversationInfo_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('channelId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSlackConversationInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getSlackConversationInfo_ConfigPropertyMetadata);
-const createResourceParams$3 = /*#__PURE__*/ createResourceParams$f(getSlackConversationInfo_ConfigPropertyMetadata);
-function keyBuilder$6(luvio, config) {
-    const resourceParams = createResourceParams$3(config);
-    return keyBuilder$7(luvio, resourceParams);
+const getSlackConversationInfo_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$4, getSlackConversationInfo_ConfigPropertyMetadata);
+const createResourceParams$4 = /*#__PURE__*/ createResourceParams$g(getSlackConversationInfo_ConfigPropertyMetadata);
+function keyBuilder$9(luvio, config) {
+    const resourceParams = createResourceParams$4(config);
+    return keyBuilder$a(luvio, resourceParams);
 }
-function typeCheckConfig$3(untrustedConfig) {
+function typeCheckConfig$4(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getSlackConversationInfo_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getSlackConversationInfo_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$4(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$3(untrustedConfig);
+    const config = typeCheckConfig$4(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$3(luvio, config) {
-    createResourceParams$3(config);
-    return select$6();
+function adapterFragment$4(luvio, config) {
+    createResourceParams$4(config);
+    return select$9();
 }
-function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
+function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$3(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$3(luvio, resourceParams, response, {
+function onFetchResponseError$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$3(luvio, config, options) {
-    const resourceParams = createResourceParams$3(config);
-    const request = createResourceRequest$3(resourceParams);
+function buildNetworkSnapshot$4(luvio, config, options) {
+    const resourceParams = createResourceParams$4(config);
+    const request = createResourceRequest$4(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$4(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
+function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$4, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$6(luvio, config),
-        node: adapterFragment$3(luvio, config),
+        recordId: keyBuilder$9(luvio, config),
+        node: adapterFragment$4(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$4(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSlackConversationInfoAdapterFactory = (luvio) => function Slack__getSlackConversationInfo(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$3(untrustedConfig, getSlackConversationInfo_ConfigPropertyNames);
+    const config = validateAdapterConfig$4(untrustedConfig, getSlackConversationInfo_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
+    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
 };
-const VERSION$2 = "1ec9fefce81c3d121b6efc55f8267a31";
-function validate$2(obj, path = 'SlackConversationInfosOutputRepresentation') {
+const VERSION$4 = "1ec9fefce81c3d121b6efc55f8267a31";
+function validate$4(obj, path = 'SlackConversationInfosOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5300,7 +5300,7 @@ function validate$2(obj, path = 'SlackConversationInfosOutputRepresentation') {
         for (let i = 0; i < obj_conversationInfos.length; i++) {
             const obj_conversationInfos_item = obj_conversationInfos[i];
             const path_conversationInfos_item = path_conversationInfos + '[' + i + ']';
-            const referencepath_conversationInfos_itemValidationError = validate$3(obj_conversationInfos_item, path_conversationInfos_item);
+            const referencepath_conversationInfos_itemValidationError = validate$5(obj_conversationInfos_item, path_conversationInfos_item);
             if (referencepath_conversationInfos_itemValidationError !== null) {
                 let message = 'Object doesn\'t match SlackConversationInfoOutputRepresentation (at "' + path_conversationInfos_item + '")\n';
                 message += referencepath_conversationInfos_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5336,15 +5336,15 @@ function validate$2(obj, path = 'SlackConversationInfosOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$2 = 'SlackConversationInfosOutputRepresentation';
-function normalize$2(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$4 = 'SlackConversationInfosOutputRepresentation';
+function normalize$4(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$5 = function SlackConversationInfosOutputRepresentationSelect() {
-    const { selections: SlackConversationInfoOutputRepresentation__selections, opaque: SlackConversationInfoOutputRepresentation__opaque, } = select$7();
+const select$8 = function SlackConversationInfosOutputRepresentationSelect() {
+    const { selections: SlackConversationInfoOutputRepresentation__selections, opaque: SlackConversationInfoOutputRepresentation__opaque, } = select$a();
     return {
         kind: 'Fragment',
-        version: VERSION$2,
+        version: VERSION$4,
         private: [],
         selections: [
             {
@@ -5360,11 +5360,11 @@ const select$5 = function SlackConversationInfosOutputRepresentationSelect() {
         ]
     };
 };
-function equals$2(existing, incoming) {
+function equals$4(existing, incoming) {
     const existing_conversationInfos = existing.conversationInfos;
     const incoming_conversationInfos = incoming.conversationInfos;
     const equals_conversationInfos_items = equalsArray(existing_conversationInfos, incoming_conversationInfos, (existing_conversationInfos_item, incoming_conversationInfos_item) => {
-        if (!(equals$3(existing_conversationInfos_item, incoming_conversationInfos_item))) {
+        if (!(equals$5(existing_conversationInfos_item, incoming_conversationInfos_item))) {
             return false;
         }
     });
@@ -5378,44 +5378,44 @@ function equals$2(existing, incoming) {
     }
     return true;
 }
-const ingest$2 = function SlackConversationInfosOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$4 = function SlackConversationInfosOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$2(input);
+        const validateError = validate$4(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$2, "Slack", VERSION$2, RepresentationType$2, equals$2);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$4, "Slack", VERSION$4, RepresentationType$4, equals$4);
     return createLink(key);
 };
-function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$2,
+        representationName: RepresentationType$4,
         mergeable: false
     });
 }
-function select$4(luvio, params) {
-    return select$5();
+function select$7(luvio, params) {
+    return select$8();
 }
-function keyBuilder$5(luvio, params) {
+function keyBuilder$8(luvio, params) {
     return keyPrefix + '::SlackConversationInfosOutputRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'search:' + params.queryParams.search + ',' + 'teamId:' + params.queryParams.teamId + ')';
 }
-function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$2(storeKeyMap, luvio, response, () => keyBuilder$5(luvio, resourceParams));
+function getResponseCacheKeys$3(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$8(luvio, resourceParams));
 }
-function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$3(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$5(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$2, body);
+    const key = keyBuilder$8(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$4(),
+        node: select$7(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5426,13 +5426,13 @@ function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$2(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$5(luvio, params);
+function ingestError$3(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$8(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$2(config) {
+function createResourceRequest$3(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -5446,96 +5446,96 @@ function createResourceRequest$2(config) {
     };
 }
-const adapterName$2 = 'getSlackSearchConversation';
+const adapterName$3 = 'getSlackSearchConversation';
 const getSlackSearchConversation_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('search', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSlackSearchConversation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getSlackSearchConversation_ConfigPropertyMetadata);
-const createResourceParams$2 = /*#__PURE__*/ createResourceParams$f(getSlackSearchConversation_ConfigPropertyMetadata);
-function keyBuilder$4(luvio, config) {
-    const resourceParams = createResourceParams$2(config);
-    return keyBuilder$5(luvio, resourceParams);
+const getSlackSearchConversation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$3, getSlackSearchConversation_ConfigPropertyMetadata);
+const createResourceParams$3 = /*#__PURE__*/ createResourceParams$g(getSlackSearchConversation_ConfigPropertyMetadata);
+function keyBuilder$7(luvio, config) {
+    const resourceParams = createResourceParams$3(config);
+    return keyBuilder$8(luvio, resourceParams);
 }
-function typeCheckConfig$2(untrustedConfig) {
+function typeCheckConfig$3(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getSlackSearchConversation_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getSlackSearchConversation_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$2(untrustedConfig);
+    const config = typeCheckConfig$3(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$2(luvio, config) {
-    createResourceParams$2(config);
-    return select$4();
+function adapterFragment$3(luvio, config) {
+    createResourceParams$3(config);
+    return select$7();
 }
-function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
+function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$2(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$2(luvio, resourceParams, response, {
+function onFetchResponseError$3(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$2(luvio, config, options) {
-    const resourceParams = createResourceParams$2(config);
-    const request = createResourceRequest$2(resourceParams);
+function buildNetworkSnapshot$3(luvio, config, options) {
+    const resourceParams = createResourceParams$3(config);
+    const request = createResourceRequest$3(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$3(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$3(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
+function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$3, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$4(luvio, config),
-        node: adapterFragment$2(luvio, config),
+        recordId: keyBuilder$7(luvio, config),
+        node: adapterFragment$3(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$3(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSlackSearchConversationAdapterFactory = (luvio) => function Slack__getSlackSearchConversation(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$2(untrustedConfig, getSlackSearchConversation_ConfigPropertyNames);
+    const config = validateAdapterConfig$3(untrustedConfig, getSlackSearchConversation_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
+    buildCachedSnapshotCachePolicy$3, buildNetworkSnapshotCachePolicy$3);
 };
-const VERSION$1 = "2ad40e0839bf44d82044e12fdedaa355";
-function validate$1(obj, path = 'SlackEmojisOutputRepresentation') {
+const VERSION$3 = "2ad40e0839bf44d82044e12fdedaa355";
+function validate$3(obj, path = 'SlackEmojisOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5548,7 +5548,7 @@ function validate$1(obj, path = 'SlackEmojisOutputRepresentation') {
         for (let i = 0; i < obj_emojis.length; i++) {
             const obj_emojis_item = obj_emojis[i];
             const path_emojis_item = path_emojis + '[' + i + ']';
-            const referencepath_emojis_itemValidationError = validate$a(obj_emojis_item, path_emojis_item);
+            const referencepath_emojis_itemValidationError = validate$c(obj_emojis_item, path_emojis_item);
             if (referencepath_emojis_itemValidationError !== null) {
                 let message = 'Object doesn\'t match SlackEmojiOutputRepresentation (at "' + path_emojis_item + '")\n';
                 message += referencepath_emojis_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -5584,15 +5584,15 @@ function validate$1(obj, path = 'SlackEmojisOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$1 = 'SlackEmojisOutputRepresentation';
-function normalize$1(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$3 = 'SlackEmojisOutputRepresentation';
+function normalize$3(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$3 = function SlackEmojisOutputRepresentationSelect() {
-    const { selections: SlackEmojiOutputRepresentation__selections, opaque: SlackEmojiOutputRepresentation__opaque, } = select$k();
+const select$6 = function SlackEmojisOutputRepresentationSelect() {
+    const { selections: SlackEmojiOutputRepresentation__selections, opaque: SlackEmojiOutputRepresentation__opaque, } = select$n();
     return {
         kind: 'Fragment',
-        version: VERSION$1,
+        version: VERSION$3,
         private: [],
         selections: [
             {
@@ -5608,11 +5608,11 @@ const select$3 = function SlackEmojisOutputRepresentationSelect() {
         ]
     };
 };
-function equals$1(existing, incoming) {
+function equals$3(existing, incoming) {
     const existing_emojis = existing.emojis;
     const incoming_emojis = incoming.emojis;
     const equals_emojis_items = equalsArray(existing_emojis, incoming_emojis, (existing_emojis_item, incoming_emojis_item) => {
-        if (!(equals$a(existing_emojis_item, incoming_emojis_item))) {
+        if (!(equals$c(existing_emojis_item, incoming_emojis_item))) {
             return false;
         }
     });
@@ -5626,44 +5626,44 @@ function equals$1(existing, incoming) {
     }
     return true;
 }
-const ingest$1 = function SlackEmojisOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$3 = function SlackEmojisOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
-        const validateError = validate$1(input);
+        const validateError = validate$3(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$1, "Slack", VERSION$1, RepresentationType$1, equals$1);
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$3, "Slack", VERSION$3, RepresentationType$3, equals$3);
     return createLink(key);
 };
-function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+function getTypeCacheKeys$3(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
-        representationName: RepresentationType$1,
+        representationName: RepresentationType$3,
         mergeable: false
     });
 }
-function select$2(luvio, params) {
-    return select$3();
+function select$5(luvio, params) {
+    return select$6();
 }
-function keyBuilder$3(luvio, params) {
+function keyBuilder$6(luvio, params) {
     return keyPrefix + '::SlackEmojisOutputRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'search:' + params.queryParams.search + ',' + 'teamId:' + params.queryParams.teamId + ')';
 }
-function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$1(storeKeyMap, luvio, response, () => keyBuilder$3(luvio, resourceParams));
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$3(storeKeyMap, luvio, response, () => keyBuilder$6(luvio, resourceParams));
 }
-function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess$2(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$3(luvio, resourceParams);
-    luvio.storeIngest(key, ingest$1, body);
+    const key = keyBuilder$6(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$3, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
-        node: select$2(),
+        node: select$5(),
         variables: {},
     }, snapshotRefresh);
     if (process.env.NODE_ENV !== 'production') {
@@ -5674,13 +5674,13 @@ function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError$1(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$3(luvio, params);
+function ingestError$2(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$6(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     luvio.storeIngestError(key, errorSnapshot);
     return errorSnapshot;
 }
-function createResourceRequest$1(config) {
+function createResourceRequest$2(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
@@ -5694,96 +5694,96 @@ function createResourceRequest$1(config) {
     };
 }
-const adapterName$1 = 'getSlackSearchEmoji';
+const adapterName$2 = 'getSlackSearchEmoji';
 const getSlackSearchEmoji_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('search', false, 1 /* QueryParameter */, 0 /* String */),
     generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSlackSearchEmoji_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getSlackSearchEmoji_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$f(getSlackSearchEmoji_ConfigPropertyMetadata);
-function keyBuilder$2(luvio, config) {
-    const resourceParams = createResourceParams$1(config);
-    return keyBuilder$3(luvio, resourceParams);
+const getSlackSearchEmoji_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, getSlackSearchEmoji_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$g(getSlackSearchEmoji_ConfigPropertyMetadata);
+function keyBuilder$5(luvio, config) {
+    const resourceParams = createResourceParams$2(config);
+    return keyBuilder$6(luvio, resourceParams);
 }
-function typeCheckConfig$1(untrustedConfig) {
+function typeCheckConfig$2(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getSlackSearchEmoji_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getSlackSearchEmoji_ConfigPropertyMetadata);
     return config;
 }
-function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
     if (!untrustedIsObject(untrustedConfig)) {
         return null;
     }
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$1(untrustedConfig);
+    const config = typeCheckConfig$2(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
     return config;
 }
-function adapterFragment$1(luvio, config) {
-    createResourceParams$1(config);
-    return select$2();
+function adapterFragment$2(luvio, config) {
+    createResourceParams$2(config);
+    return select$5();
 }
-function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
+function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$2(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function onFetchResponseError$1(luvio, config, resourceParams, response) {
-    const snapshot = ingestError$1(luvio, resourceParams, response, {
+function onFetchResponseError$2(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$2(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$1(luvio, config, options) {
-    const resourceParams = createResourceParams$1(config);
-    const request = createResourceRequest$1(resourceParams);
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$2(luvio, config, resourceParams, response), () => {
             const cache = new StoreKeyMap();
-            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$2(luvio, config, resourceParams, response));
     });
 }
-function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
+function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$2, undefined, false);
 }
-function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+function buildCachedSnapshotCachePolicy$2(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$2(luvio, config),
-        node: adapterFragment$1(luvio, config),
+        recordId: keyBuilder$5(luvio, config),
+        node: adapterFragment$2(luvio, config),
         variables: {},
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$2(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
 const getSlackSearchEmojiAdapterFactory = (luvio) => function Slack__getSlackSearchEmoji(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig$1(untrustedConfig, getSlackSearchEmoji_ConfigPropertyNames);
+    const config = validateAdapterConfig$2(untrustedConfig, getSlackSearchEmoji_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
     }
     return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+    buildCachedSnapshotCachePolicy$2, buildNetworkSnapshotCachePolicy$2);
 };
-const VERSION = "a63b46e1ce1ae5776406a41eb3182812";
-function validate(obj, path = 'SlackUserInfosOutputRepresentation') {
+const VERSION$2 = "a63b46e1ce1ae5776406a41eb3182812";
+function validate$2(obj, path = 'SlackUserInfosOutputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -5829,14 +5829,14 @@ function validate(obj, path = 'SlackUserInfosOutputRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType = 'SlackUserInfosOutputRepresentation';
-function normalize(input, existing, path, luvio, store, timestamp) {
+const RepresentationType$2 = 'SlackUserInfosOutputRepresentation';
+function normalize$2(input, existing, path, luvio, store, timestamp) {
     const input_userInfos = input.userInfos;
     const input_userInfos_id = path.fullPath + '__userInfos';
     for (let i = 0; i < input_userInfos.length; i++) {
         const input_userInfos_item = input_userInfos[i];
         let input_userInfos_item_id = input_userInfos_id + '__' + i;
-        input_userInfos[i] = ingest$9(input_userInfos_item, {
+        input_userInfos[i] = ingest$b(input_userInfos_item, {
             fullPath: input_userInfos_item_id,
             propertyName: i,
             parent: {
@@ -5849,10 +5849,10 @@ function normalize(input, existing, path, luvio, store, timestamp) {
     }
     return input;
 }
-const select$1 = function SlackUserInfosOutputRepresentationSelect() {
+const select$4 = function SlackUserInfosOutputRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION,
+        version: VERSION$2,
         private: [],
         selections: [
             {
@@ -5863,12 +5863,12 @@ const select$1 = function SlackUserInfosOutputRepresentationSelect() {
                 name: 'userInfos',
                 kind: 'Link',
                 plural: true,
-                fragment: select$j()
+                fragment: select$m()
             }
         ]
     };
 };
-function equals(existing, incoming) {
+function equals$2(existing, incoming) {
     const existing_searchString = existing.searchString;
     const incoming_searchString = incoming.searchString;
     if (!(existing_searchString === incoming_searchString)) {
@@ -5886,7 +5886,320 @@ function equals(existing, incoming) {
     }
     return true;
 }
-const ingest = function SlackUserInfosOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$2 = function SlackUserInfosOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$2(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$2, "Slack", VERSION$2, RepresentationType$2, equals$2);
+    return createLink(key);
+};
+function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+    const input_userInfos_length = input.userInfos.length;
+    for (let i = 0; i < input_userInfos_length; i++) {
+        getTypeCacheKeys$b(rootKeySet, luvio, input.userInfos[i]);
+    }
+}
+function select$3(luvio, params) {
+    return select$4();
+}
+function keyBuilder$4(luvio, params) {
+    return keyPrefix + '::SlackUserInfosOutputRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'search:' + params.queryParams.search + ',' + 'teamId:' + params.queryParams.teamId + ')';
+}
+function getResponseCacheKeys$1(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response, () => keyBuilder$4(luvio, resourceParams));
+}
+function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$4(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$3(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$1(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$4(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$1(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v64.0',
+        basePath: '/connect/swarming/slack/search/user',
+        method: 'get',
+        body: null,
+        urlParams: {},
+        queryParams: config.queryParams,
+        headers,
+        priority: 'normal',
+    };
+}
+const adapterName$1 = 'getSlackSearchUser';
+const getSlackSearchUser_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('search', false, 1 /* QueryParameter */, 0 /* String */),
+    generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
+];
+const getSlackSearchUser_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, getSlackSearchUser_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$g(getSlackSearchUser_ConfigPropertyMetadata);
+function keyBuilder$3(luvio, config) {
+    const resourceParams = createResourceParams$1(config);
+    return keyBuilder$4(luvio, resourceParams);
+}
+function typeCheckConfig$1(untrustedConfig) {
+    const config = {};
+    typeCheckConfig$g(untrustedConfig, config, getSlackSearchUser_ConfigPropertyMetadata);
+    return config;
+}
+function validateAdapterConfig$1(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$1(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$1(luvio, config) {
+    createResourceParams$1(config);
+    return select$3();
+}
+function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$1(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$1(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$1(luvio, config, options) {
+    const resourceParams = createResourceParams$1(config);
+    const request = createResourceRequest$1(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot$1, undefined, false);
+}
+function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$3(luvio, config),
+        node: adapterFragment$1(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getSlackSearchUserAdapterFactory = (luvio) => function Slack__getSlackSearchUser(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$1(untrustedConfig, getSlackSearchUser_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+};
+const VERSION$1 = "6453ed899bced31c850a412b8852eba0";
+function validate$1(obj, path = 'SlackWorkspaceOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        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_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'SlackWorkspaceOutputRepresentation';
+function keyBuilder$2(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + config.id;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        id: object.id
+    };
+    return keyBuilder$2(luvio, keyParams);
+}
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$2 = function SlackWorkspaceOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        selections: [
+            {
+                name: 'id',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$1(existing, incoming) {
+    const existing_id = existing.id;
+    const incoming_id = incoming.id;
+    if (!(existing_id === incoming_id)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    return true;
+}
+const ingest$1 = function SlackWorkspaceOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$1(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType(luvio, input);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 60000;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$1, "Slack", VERSION$1, RepresentationType$1, equals$1);
+    return createLink(key);
+};
+function getTypeCacheKeys$1(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$1,
+        mergeable: false
+    });
+}
+const VERSION = "d9c689c48bbf920db76831d7dd0de8b0";
+function validate(obj, path = 'SlackWorkspaceListOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_slackWorkspaceList = obj.slackWorkspaceList;
+        const path_slackWorkspaceList = path + '.slackWorkspaceList';
+        if (!ArrayIsArray(obj_slackWorkspaceList)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_slackWorkspaceList + '" (at "' + path_slackWorkspaceList + '")');
+        }
+        for (let i = 0; i < obj_slackWorkspaceList.length; i++) {
+            const obj_slackWorkspaceList_item = obj_slackWorkspaceList[i];
+            const path_slackWorkspaceList_item = path_slackWorkspaceList + '[' + i + ']';
+            if (typeof obj_slackWorkspaceList_item !== 'object') {
+                return new TypeError('Expected "object" but received "' + typeof obj_slackWorkspaceList_item + '" (at "' + path_slackWorkspaceList_item + '")');
+            }
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType = 'SlackWorkspaceListOutputRepresentation';
+function normalize(input, existing, path, luvio, store, timestamp) {
+    const input_slackWorkspaceList = input.slackWorkspaceList;
+    const input_slackWorkspaceList_id = path.fullPath + '__slackWorkspaceList';
+    for (let i = 0; i < input_slackWorkspaceList.length; i++) {
+        const input_slackWorkspaceList_item = input_slackWorkspaceList[i];
+        let input_slackWorkspaceList_item_id = input_slackWorkspaceList_id + '__' + i;
+        input_slackWorkspaceList[i] = ingest$1(input_slackWorkspaceList_item, {
+            fullPath: input_slackWorkspaceList_item_id,
+            propertyName: i,
+            parent: {
+                data: input,
+                key: path.fullPath,
+                existing: existing,
+            },
+            ttl: path.ttl
+        }, luvio, store, timestamp);
+    }
+    return input;
+}
+const select$1 = function SlackWorkspaceListOutputRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION,
+        private: [],
+        selections: [
+            {
+                name: 'slackWorkspaceList',
+                kind: 'Link',
+                plural: true,
+                fragment: select$2()
+            }
+        ]
+    };
+};
+function equals(existing, incoming) {
+    const existing_slackWorkspaceList = existing.slackWorkspaceList;
+    const incoming_slackWorkspaceList = incoming.slackWorkspaceList;
+    const equals_slackWorkspaceList_items = equalsArray(existing_slackWorkspaceList, incoming_slackWorkspaceList, (existing_slackWorkspaceList_item, incoming_slackWorkspaceList_item) => {
+        if (!(existing_slackWorkspaceList_item.__ref === incoming_slackWorkspaceList_item.__ref)) {
+            return false;
+        }
+    });
+    if (equals_slackWorkspaceList_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest = function SlackWorkspaceListOutputRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate(input);
         if (validateError !== null) {
@@ -5906,9 +6219,9 @@ function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
         representationName: RepresentationType,
         mergeable: false
     });
-    const input_userInfos_length = input.userInfos.length;
-    for (let i = 0; i < input_userInfos_length; i++) {
-        getTypeCacheKeys$9(rootKeySet, luvio, input.userInfos[i]);
+    const input_slackWorkspaceList_length = input.slackWorkspaceList.length;
+    for (let i = 0; i < input_slackWorkspaceList_length; i++) {
+        getTypeCacheKeys$1(rootKeySet, luvio, input.slackWorkspaceList[i]);
     }
 }
@@ -5916,7 +6229,7 @@ function select(luvio, params) {
     return select$1();
 }
 function keyBuilder$1(luvio, params) {
-    return keyPrefix + '::SlackUserInfosOutputRepresentation:(' + 'appId:' + params.queryParams.appId + ',' + 'search:' + params.queryParams.search + ',' + 'teamId:' + params.queryParams.teamId + ')';
+    return keyPrefix + '::SlackWorkspaceListOutputRepresentation:(' + 'appId:' + params.queryParams.appId + ')';
 }
 function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
     getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$1(luvio, resourceParams));
@@ -5948,7 +6261,7 @@ function createResourceRequest(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v64.0',
-        basePath: '/connect/swarming/slack/search/user',
+        basePath: '/connect/swarming/workspaces',
         method: 'get',
         body: null,
         urlParams: {},
@@ -5958,21 +6271,19 @@ function createResourceRequest(config) {
     };
 }
-const adapterName = 'getSlackSearchUser';
-const getSlackSearchUser_ConfigPropertyMetadata = [
+const adapterName = 'getSlackWorkspace';
+const getSlackWorkspace_ConfigPropertyMetadata = [
     generateParamConfigMetadata('appId', false, 1 /* QueryParameter */, 0 /* String */),
-    generateParamConfigMetadata('search', false, 1 /* QueryParameter */, 0 /* String */),
-    generateParamConfigMetadata('teamId', false, 1 /* QueryParameter */, 0 /* String */),
 ];
-const getSlackSearchUser_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getSlackSearchUser_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$f(getSlackSearchUser_ConfigPropertyMetadata);
+const getSlackWorkspace_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getSlackWorkspace_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$g(getSlackWorkspace_ConfigPropertyMetadata);
 function keyBuilder(luvio, config) {
     const resourceParams = createResourceParams(config);
     return keyBuilder$1(luvio, resourceParams);
 }
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$f(untrustedConfig, config, getSlackSearchUser_ConfigPropertyMetadata);
+    typeCheckConfig$g(untrustedConfig, config, getSlackWorkspace_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig(untrustedConfig, configPropertyNames) {
@@ -6021,7 +6332,7 @@ function buildNetworkSnapshot(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
+    return buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext, buildNetworkSnapshot, undefined, false);
 }
 function buildCachedSnapshotCachePolicy(context, storeLookup) {
     const { luvio, config } = context;
@@ -6036,8 +6347,8 @@ function buildCachedSnapshotCachePolicy(context, storeLookup) {
     });
     return cacheSnapshot;
 }
-const getSlackSearchUserAdapterFactory = (luvio) => function Slack__getSlackSearchUser(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig(untrustedConfig, getSlackSearchUser_ConfigPropertyNames);
+const getSlackWorkspaceAdapterFactory = (luvio) => function Slack__getSlackWorkspace(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig(untrustedConfig, getSlackWorkspace_ConfigPropertyNames);
     // Invalid or incomplete config
     if (config === null) {
         return null;
@@ -6046,4 +6357,4 @@ const getSlackSearchUserAdapterFactory = (luvio) => function Slack__getSlackSear
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
-export { deleteSlackMessageAdapterFactory, deleteSlackMessageReactionsAdapterFactory, getSlackConversationAdapterFactory, getSlackConversationInfoAdapterFactory, getSlackCustomEmojiAdapterFactory, getSlackMessageAdapterFactory, getSlackSalesforceAuthAdapterFactory, getSlackSearchConversationAdapterFactory, getSlackSearchEmojiAdapterFactory, getSlackSearchUserAdapterFactory, getSlackUserAdapterFactory, patchSlackMessageAdapterFactory, postSlackConversationAdapterFactory, postSlackFileAdapterFactory, postSlackMessageReactionsAdapterFactory };
+export { deleteSlackMessageAdapterFactory, deleteSlackMessageReactionsAdapterFactory, getSlackConversationAdapterFactory, getSlackConversationInfoAdapterFactory, getSlackCustomEmojiAdapterFactory, getSlackMessageAdapterFactory, getSlackSalesforceAuthAdapterFactory, getSlackSearchConversationAdapterFactory, getSlackSearchEmojiAdapterFactory, getSlackSearchUserAdapterFactory, getSlackUserAdapterFactory, getSlackWorkspaceAdapterFactory, patchSlackMessageAdapterFactory, postSlackConversationAdapterFactory, postSlackFileAdapterFactory, postSlackMessageReactionsAdapterFactory };